Add files using upload-large-folder tool

projects/ui/serena-new/src/serena/constants.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+_repo_root_path = Path(__file__).parent.parent.parent.resolve()
+_serena_pkg_path = Path(__file__).parent.resolve()
+
+SERENA_MANAGED_DIR_NAME = ".serena"
+_serena_in_home_managed_dir = Path.home() / ".serena"
+
+SERENA_MANAGED_DIR_IN_HOME = str(_serena_in_home_managed_dir)
+
+# TODO: Path-related constants should be moved to SerenaPaths; don't add further constants here.
+REPO_ROOT = str(_repo_root_path)
+PROMPT_TEMPLATES_DIR_INTERNAL = str(_serena_pkg_path / "resources" / "config" / "prompt_templates")
+PROMPT_TEMPLATES_DIR_IN_USER_HOME = str(_serena_in_home_managed_dir / "prompt_templates")
+SERENAS_OWN_CONTEXT_YAMLS_DIR = str(_serena_pkg_path / "resources" / "config" / "contexts")
+"""The contexts that are shipped with the Serena package, i.e. the default contexts."""
+USER_CONTEXT_YAMLS_DIR = str(_serena_in_home_managed_dir / "contexts")
+"""Contexts defined by the user. If a name of a context matches a name of a context in SERENAS_OWN_CONTEXT_YAMLS_DIR, the user context will override the default one."""
+SERENAS_OWN_MODE_YAMLS_DIR = str(_serena_pkg_path / "resources" / "config" / "modes")
+"""The modes that are shipped with the Serena package, i.e. the default modes."""
+USER_MODE_YAMLS_DIR = str(_serena_in_home_managed_dir / "modes")
+"""Modes defined by the user. If a name of a mode matches a name of a mode in SERENAS_OWN_MODE_YAMLS_DIR, the user mode will override the default one."""
+INTERNAL_MODE_YAMLS_DIR = str(_serena_pkg_path / "resources" / "config" / "internal_modes")
+"""Internal modes, never overridden by user modes."""
+SERENA_DASHBOARD_DIR = str(_serena_pkg_path / "resources" / "dashboard")
+SERENA_ICON_DIR = str(_serena_pkg_path / "resources" / "icons")
+
+DEFAULT_ENCODING = "utf-8"
+DEFAULT_CONTEXT = "desktop-app"
+DEFAULT_MODES = ("interactive", "editing")
+
+PROJECT_TEMPLATE_FILE = str(_serena_pkg_path / "resources" / "project.template.yml")
+SERENA_CONFIG_TEMPLATE_FILE = str(_serena_pkg_path / "resources" / "serena_config.template.yml")
+
+SERENA_LOG_FORMAT = "%(levelname)-5s %(asctime)-15s [%(threadName)s] %(name)s:%(funcName)s:%(lineno)d - %(message)s"

projects/ui/serena-new/src/serena/dashboard.py

@@ -0,0 +1,162 @@
+import os
+import socket
+import threading
+from collections.abc import Callable
+from typing import Any
+
+from flask import Flask, Response, request, send_from_directory
+from pydantic import BaseModel
+from sensai.util import logging
+
+from serena.analytics import ToolUsageStats
+from serena.constants import SERENA_DASHBOARD_DIR
+from serena.util.logging import MemoryLogHandler
+
+log = logging.getLogger(__name__)
+
+# disable Werkzeug's logging to avoid cluttering the output
+logging.getLogger("werkzeug").setLevel(logging.WARNING)
+
+
+class RequestLog(BaseModel):
+    start_idx: int = 0
+
+
+class ResponseLog(BaseModel):
+    messages: list[str]
+    max_idx: int
+
+
+class ResponseToolNames(BaseModel):
+    tool_names: list[str]
+
+
+class ResponseToolStats(BaseModel):
+    stats: dict[str, dict[str, int]]
+
+
+class SerenaDashboardAPI:
+    log = logging.getLogger(__qualname__)
+
+    def __init__(
+        self,
+        memory_log_handler: MemoryLogHandler,
+        tool_names: list[str],
+        shutdown_callback: Callable[[], None] | None = None,
+        tool_usage_stats: ToolUsageStats | None = None,
+    ) -> None:
+        self._memory_log_handler = memory_log_handler
+        self._tool_names = tool_names
+        self._shutdown_callback = shutdown_callback
+        self._app = Flask(__name__)
+        self._tool_usage_stats = tool_usage_stats
+        self._setup_routes()
+
+    @property
+    def memory_log_handler(self) -> MemoryLogHandler:
+        return self._memory_log_handler
+
+    def _setup_routes(self) -> None:
+        # Static files
+        @self._app.route("/dashboard/<path:filename>")
+        def serve_dashboard(filename: str) -> Response:
+            return send_from_directory(SERENA_DASHBOARD_DIR, filename)
+
+        @self._app.route("/dashboard/")
+        def serve_dashboard_index() -> Response:
+            return send_from_directory(SERENA_DASHBOARD_DIR, "index.html")
+
+        # API routes
+        @self._app.route("/get_log_messages", methods=["POST"])
+        def get_log_messages() -> dict[str, Any]:
+            request_data = request.get_json()
+            if not request_data:
+                request_log = RequestLog()
+            else:
+                request_log = RequestLog.model_validate(request_data)
+
+            result = self._get_log_messages(request_log)
+            return result.model_dump()
+
+        @self._app.route("/get_tool_names", methods=["GET"])
+        def get_tool_names() -> dict[str, Any]:
+            result = self._get_tool_names()
+            return result.model_dump()
+
+        @self._app.route("/get_tool_stats", methods=["GET"])
+        def get_tool_stats_route() -> dict[str, Any]:
+            result = self._get_tool_stats()
+            return result.model_dump()
+
+        @self._app.route("/clear_tool_stats", methods=["POST"])
+        def clear_tool_stats_route() -> dict[str, str]:
+            self._clear_tool_stats()
+            return {"status": "cleared"}
+
+        @self._app.route("/get_token_count_estimator_name", methods=["GET"])
+        def get_token_count_estimator_name() -> dict[str, str]:
+            estimator_name = self._tool_usage_stats.token_estimator_name if self._tool_usage_stats else "unknown"
+            return {"token_count_estimator_name": estimator_name}
+
+        @self._app.route("/shutdown", methods=["PUT"])
+        def shutdown() -> dict[str, str]:
+            self._shutdown()
+            return {"status": "shutting down"}
+
+    def _get_log_messages(self, request_log: RequestLog) -> ResponseLog:
+        all_messages = self._memory_log_handler.get_log_messages()
+        requested_messages = all_messages[request_log.start_idx :] if request_log.start_idx <= len(all_messages) else []
+        return ResponseLog(messages=requested_messages, max_idx=len(all_messages) - 1)
+
+    def _get_tool_names(self) -> ResponseToolNames:
+        return ResponseToolNames(tool_names=self._tool_names)
+
+    def _get_tool_stats(self) -> ResponseToolStats:
+        if self._tool_usage_stats is not None:
+            return ResponseToolStats(stats=self._tool_usage_stats.get_tool_stats_dict())
+        else:
+            return ResponseToolStats(stats={})
+
+    def _clear_tool_stats(self) -> None:
+        if self._tool_usage_stats is not None:
+            self._tool_usage_stats.clear()
+
+    def _shutdown(self) -> None:
+        log.info("Shutting down Serena")
+        if self._shutdown_callback:
+            self._shutdown_callback()
+        else:
+            # noinspection PyProtectedMember
+            # noinspection PyUnresolvedReferences
+            os._exit(0)
+
+    @staticmethod
+    def _find_first_free_port(start_port: int) -> int:
+        port = start_port
+        while port <= 65535:
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                    sock.bind(("0.0.0.0", port))
+                    return port
+            except OSError:
+                port += 1
+
+        raise RuntimeError(f"No free ports found starting from {start_port}")
+
+    def run(self, host: str = "0.0.0.0", port: int = 0x5EDA) -> int:
+        """
+        Runs the dashboard on the given host and port and returns the port number.
+        """
+        # patch flask.cli.show_server to avoid printing the server info
+        from flask import cli
+
+        cli.show_server_banner = lambda *args, **kwargs: None
+
+        self._app.run(host=host, port=port, debug=False, use_reloader=False, threaded=True)
+        return port
+
+    def run_in_thread(self) -> tuple[threading.Thread, int]:
+        port = self._find_first_free_port(0x5EDA)
+        thread = threading.Thread(target=lambda: self.run(port=port), daemon=True)
+        thread.start()
+        return thread, port

projects/ui/serena-new/src/serena/gui_log_viewer.py

@@ -0,0 +1,405 @@
+# mypy: ignore-errors
+import logging
+import os
+import queue
+import sys
+import threading
+import tkinter as tk
+import traceback
+from enum import Enum, auto
+from pathlib import Path
+from typing import Literal
+
+from serena import constants
+from serena.util.logging import MemoryLogHandler
+
+log = logging.getLogger(__name__)
+
+
+class LogLevel(Enum):
+    DEBUG = auto()
+    INFO = auto()
+    WARNING = auto()
+    ERROR = auto()
+    DEFAULT = auto()
+
+
+class GuiLogViewer:
+    """
+    A class that creates a Tkinter GUI for displaying log messages in a separate thread.
+    The log viewer supports coloring based on log levels (DEBUG, INFO, WARNING, ERROR).
+    It can also highlight tool names in boldface when they appear in log messages.
+    """
+
+    def __init__(
+        self,
+        mode: Literal["dashboard", "error"],
+        title="Log Viewer",
+        memory_log_handler: MemoryLogHandler | None = None,
+        width=800,
+        height=600,
+    ):
+        """
+        :param mode: the mode; if "dashboard", run a dashboard with logs and some control options; if "error", run
+            a simple error log viewer (for fatal exceptions)
+        :param title: the window title
+        :param memory_log_handler: an optional log handler from which to obtain log messages; If not provided,
+            must pass the instance to a `GuiLogViewerHandler` to add log messages.
+        :param width: the initial window width
+        :param height: the initial window height
+        """
+        self.mode = mode
+        self.title = title
+        self.width = width
+        self.height = height
+        self.message_queue = queue.Queue()
+        self.running = False
+        self.log_thread = None
+        self.tool_names = []  # List to store tool names for highlighting
+
+        # Define colors for different log levels
+        self.log_colors = {
+            LogLevel.DEBUG: "#808080",  # Gray
+            LogLevel.INFO: "#000000",  # Black
+            LogLevel.WARNING: "#FF8C00",  # Dark Orange
+            LogLevel.ERROR: "#FF0000",  # Red
+            LogLevel.DEFAULT: "#000000",  # Black
+        }
+
+        if memory_log_handler is not None:
+            for msg in memory_log_handler.get_log_messages():
+                self.message_queue.put(msg)
+            memory_log_handler.add_emit_callback(lambda msg: self.message_queue.put(msg))
+
+    def start(self):
+        """Start the log viewer in a separate thread."""
+        if not self.running:
+            self.log_thread = threading.Thread(target=self.run_gui)
+            self.log_thread.daemon = True
+            self.log_thread.start()
+            return True
+        return False
+
+    def stop(self):
+        """Stop the log viewer."""
+        if self.running:
+            # Add a sentinel value to the queue to signal the GUI to exit
+            self.message_queue.put(None)
+            return True
+        return False
+
+    def set_tool_names(self, tool_names):
+        """
+        Set or update the list of tool names to be highlighted in log messages.
+
+        Args:
+            tool_names (list): A list of tool name strings to highlight
+
+        """
+        self.tool_names = tool_names
+
+    def add_log(self, message):
+        """
+        Add a log message to the viewer.
+
+        Args:
+            message (str): The log message to display
+
+        """
+        self.message_queue.put(message)
+
+    def _determine_log_level(self, message):
+        """
+        Determine the log level from the message.
+
+        Args:
+            message (str): The log message
+
+        Returns:
+            LogLevel: The determined log level
+
+        """
+        message_upper = message.upper()
+        if message_upper.startswith("DEBUG"):
+            return LogLevel.DEBUG
+        elif message_upper.startswith("INFO"):
+            return LogLevel.INFO
+        elif message_upper.startswith("WARNING"):
+            return LogLevel.WARNING
+        elif message_upper.startswith("ERROR"):
+            return LogLevel.ERROR
+        else:
+            return LogLevel.DEFAULT
+
+    def _process_queue(self):
+        """Process messages from the queue and update the text widget."""
+        try:
+            while not self.message_queue.empty():
+                message = self.message_queue.get_nowait()
+
+                # Check for sentinel value to exit
+                if message is None:
+                    self.root.quit()
+                    return
+
+                # Check if scrollbar is at the bottom before adding new text
+                # Get current scroll position
+                current_position = self.text_widget.yview()
+                # If near the bottom (allowing for small floating point differences)
+                was_at_bottom = current_position[1] > 0.99
+
+                log_level = self._determine_log_level(message)
+
+                # Insert the message at the end of the text with appropriate log level tag
+                self.text_widget.configure(state=tk.NORMAL)
+
+                # Find tool names in the message and highlight them
+                if self.tool_names:
+                    # Capture start position (before insertion)
+                    start_index = self.text_widget.index("end-1c")
+
+                    # Insert the message
+                    self.text_widget.insert(tk.END, message + "\n", log_level.name)
+
+                    # Convert start index to line/char format
+                    line, char = map(int, start_index.split("."))
+
+                    # Search for tool names in the message string directly
+                    for tool_name in self.tool_names:
+                        start_offset = 0
+                        while True:
+                            found_at = message.find(tool_name, start_offset)
+                            if found_at == -1:
+                                break
+
+                            # Calculate line/column from offset
+                            offset_line = line
+                            offset_char = char
+                            for c in message[:found_at]:
+                                if c == "\n":
+                                    offset_line += 1
+                                    offset_char = 0
+                                else:
+                                    offset_char += 1
+
+                            # Construct index positions
+                            start_pos = f"{offset_line}.{offset_char}"
+                            end_pos = f"{offset_line}.{offset_char + len(tool_name)}"
+
+                            # Add tag to highlight the tool name
+                            self.text_widget.tag_add("TOOL_NAME", start_pos, end_pos)
+
+                            start_offset = found_at + len(tool_name)
+
+                else:
+                    # No tool names to highlight, just insert the message
+                    self.text_widget.insert(tk.END, message + "\n", log_level.name)
+
+                self.text_widget.configure(state=tk.DISABLED)
+
+                # Auto-scroll to the bottom only if it was already at the bottom
+                if was_at_bottom:
+                    self.text_widget.see(tk.END)
+
+            # Schedule to check the queue again
+            if self.running:
+                self.root.after(100, self._process_queue)
+
+        except Exception as e:
+            print(f"Error processing message queue: {e}", file=sys.stderr)
+            if self.running:
+                self.root.after(100, self._process_queue)
+
+    def run_gui(self):
+        """Run the GUI"""
+        self.running = True
+        try:
+            # Set app id (avoid app being lumped together with other Python-based apps in Windows taskbar)
+            if sys.platform == "win32":
+                import ctypes
+
+                ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("oraios.serena")
+
+            self.root = tk.Tk()
+            self.root.title(self.title)
+            self.root.geometry(f"{self.width}x{self.height}")
+
+            # Make the window resizable
+            self.root.columnconfigure(0, weight=1)
+            # We now have two rows - one for logo and one for text
+            self.root.rowconfigure(0, weight=0)  # Logo row
+            self.root.rowconfigure(1, weight=1)  # Text content row
+
+            dashboard_path = Path(constants.SERENA_DASHBOARD_DIR)
+
+            # Load and display the logo image
+            try:
+                # construct path relative to path of this file
+                image_path = dashboard_path / "serena-logs.png"
+                self.logo_image = tk.PhotoImage(file=image_path)
+
+                # Create a label to display the logo
+                self.logo_label = tk.Label(self.root, image=self.logo_image)
+                self.logo_label.grid(row=0, column=0, sticky="ew")
+            except Exception as e:
+                print(f"Error loading logo image: {e}", file=sys.stderr)
+
+            # Create frame to hold text widget and scrollbars
+            frame = tk.Frame(self.root)
+            frame.grid(row=1, column=0, sticky="nsew")
+            frame.columnconfigure(0, weight=1)
+            frame.rowconfigure(0, weight=1)
+
+            # Create horizontal scrollbar
+            h_scrollbar = tk.Scrollbar(frame, orient=tk.HORIZONTAL)
+            h_scrollbar.grid(row=1, column=0, sticky="ew")
+
+            # Create vertical scrollbar
+            v_scrollbar = tk.Scrollbar(frame, orient=tk.VERTICAL)
+            v_scrollbar.grid(row=0, column=1, sticky="ns")
+
+            # Create text widget with horizontal scrolling
+            self.text_widget = tk.Text(
+                frame, wrap=tk.NONE, width=self.width, height=self.height, xscrollcommand=h_scrollbar.set, yscrollcommand=v_scrollbar.set
+            )
+            self.text_widget.grid(row=0, column=0, sticky="nsew")
+            self.text_widget.configure(state=tk.DISABLED)  # Make it read-only
+
+            # Configure scrollbars
+            h_scrollbar.config(command=self.text_widget.xview)
+            v_scrollbar.config(command=self.text_widget.yview)
+
+            # Configure tags for different log levels with appropriate colors
+            for level, color in self.log_colors.items():
+                self.text_widget.tag_configure(level.name, foreground=color)
+
+            # Configure tag for tool names
+            self.text_widget.tag_configure("TOOL_NAME", background="#ffff00")
+
+            # Set up the queue processing
+            self.root.after(100, self._process_queue)
+
+            # Handle window close event depending on mode
+            if self.mode == "dashboard":
+                self.root.protocol("WM_DELETE_WINDOW", lambda: self.root.iconify())
+            else:
+                self.root.protocol("WM_DELETE_WINDOW", self.stop)
+
+            # Create menu bar
+            if self.mode == "dashboard":
+                menubar = tk.Menu(self.root)
+                server_menu = tk.Menu(menubar, tearoff=0)
+                server_menu.add_command(label="Shutdown", command=self._shutdown_server)  # type: ignore
+                menubar.add_cascade(label="Server", menu=server_menu)
+                self.root.config(menu=menubar)
+
+            # Configure icons
+            icon_16 = tk.PhotoImage(file=dashboard_path / "serena-icon-16.png")
+            icon_32 = tk.PhotoImage(file=dashboard_path / "serena-icon-32.png")
+            icon_48 = tk.PhotoImage(file=dashboard_path / "serena-icon-48.png")
+            self.root.iconphoto(False, icon_48, icon_32, icon_16)
+
+            # Start the Tkinter event loop
+            self.root.mainloop()
+
+        except Exception as e:
+            print(f"Error in GUI thread: {e}", file=sys.stderr)
+        finally:
+            self.running = False
+
+    def _shutdown_server(self) -> None:
+        log.info("Shutting down Serena")
+        # noinspection PyUnresolvedReferences
+        # noinspection PyProtectedMember
+        os._exit(0)
+
+
+class GuiLogViewerHandler(logging.Handler):
+    """
+    A logging handler that sends log records to a ThreadedLogViewer instance.
+    This handler can be integrated with Python's standard logging module
+    to direct log entries to a GUI log viewer.
+    """
+
+    def __init__(
+        self,
+        log_viewer: GuiLogViewer,
+        level=logging.NOTSET,
+        format_string: str | None = "%(levelname)-5s %(asctime)-15s %(name)s:%(funcName)s:%(lineno)d - %(message)s",
+    ):
+        """
+        Initialize the handler with a ThreadedLogViewer instance.
+
+        Args:
+            log_viewer: A ThreadedLogViewer instance that will display the logs
+            level: The logging level (default: NOTSET which captures all logs)
+            format_string: the format string
+
+        """
+        super().__init__(level)
+        self.log_viewer = log_viewer
+        self.formatter = logging.Formatter(format_string)
+
+        # Start the log viewer if it's not already running
+        if not self.log_viewer.running:
+            self.log_viewer.start()
+
+    @classmethod
+    def is_instance_registered(cls) -> bool:
+        for h in logging.Logger.root.handlers:
+            if isinstance(h, cls):
+                return True
+        return False
+
+    def emit(self, record):
+        """
+        Emit a log record to the ThreadedLogViewer.
+
+        Args:
+            record: The log record to emit
+
+        """
+        try:
+            # Format the record according to the formatter
+            msg = self.format(record)
+
+            # Convert the level name to a standard format for the viewer
+            level_prefix = record.levelname
+
+            # Add the appropriate prefix if it's not already there
+            if not msg.startswith(level_prefix):
+                msg = f"{level_prefix}: {msg}"
+
+            self.log_viewer.add_log(msg)
+
+        except Exception:
+            self.handleError(record)
+
+    def close(self):
+        """
+        Close the handler and optionally stop the log viewer.
+        """
+        # We don't automatically stop the log viewer here as it might
+        # be used by other handlers or directly by the application
+        super().close()
+
+    def stop_viewer(self):
+        """
+        Explicitly stop the associated log viewer.
+        """
+        if self.log_viewer.running:
+            self.log_viewer.stop()
+
+
+def show_fatal_exception(e: Exception):
+    """
+    Makes sure the given exception is shown in the GUI log viewer,
+    either an existing instance or a new one.
+
+    :param e: the exception to display
+    """
+    # show in new window in main thread (user must close it)
+    log_viewer = GuiLogViewer("error")
+    exc_info = "".join(traceback.format_exception(type(e), e, e.__traceback__))
+    log_viewer.add_log(f"ERROR Fatal exception: {e}\n{exc_info}")
+    log_viewer.run_gui()

projects/ui/serena-new/src/serena/mcp.py

@@ -0,0 +1,348 @@
+"""
+The Serena Model Context Protocol (MCP) Server
+"""
+
+import sys
+from abc import abstractmethod
+from collections.abc import AsyncIterator, Iterator, Sequence
+from contextlib import asynccontextmanager
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Literal, cast
+
+import docstring_parser
+from mcp.server.fastmcp import server
+from mcp.server.fastmcp.server import FastMCP, Settings
+from mcp.server.fastmcp.tools.base import Tool as MCPTool
+from pydantic_settings import SettingsConfigDict
+from sensai.util import logging
+
+from serena.agent import (
+    SerenaAgent,
+    SerenaConfig,
+)
+from serena.config.context_mode import SerenaAgentContext, SerenaAgentMode
+from serena.constants import DEFAULT_CONTEXT, DEFAULT_MODES, SERENA_LOG_FORMAT
+from serena.tools import Tool
+from serena.util.exception import show_fatal_exception_safe
+from serena.util.logging import MemoryLogHandler
+
+log = logging.getLogger(__name__)
+
+
+def configure_logging(*args, **kwargs) -> None:  # type: ignore
+    # We only do something here if logging has not yet been configured.
+    # Normally, logging is configured in the MCP server startup script.
+    if not logging.is_enabled():
+        logging.basicConfig(level=logging.INFO, stream=sys.stderr, format=SERENA_LOG_FORMAT)
+
+
+# patch the logging configuration function in fastmcp, because it's hard-coded and broken
+server.configure_logging = configure_logging  # type: ignore
+
+
+@dataclass
+class SerenaMCPRequestContext:
+    agent: SerenaAgent
+
+
+class SerenaMCPFactory:
+    def __init__(self, context: str = DEFAULT_CONTEXT, project: str | None = None):
+        """
+        :param context: The context name or path to context file
+        :param project: Either an absolute path to the project directory or a name of an already registered project.
+            If the project passed here hasn't been registered yet, it will be registered automatically and can be activated by its name
+            afterward.
+        """
+        self.context = SerenaAgentContext.load(context)
+        self.project = project
+
+    @staticmethod
+    def _sanitize_for_openai_tools(schema: dict) -> dict:
+        """
+        This method was written by GPT-5, I have not reviewed it in detail.
+        Only called when `openai_tool_compatible` is True.
+
+        Make a Pydantic/JSON Schema object compatible with OpenAI tool schema.
+        - 'integer' -> 'number' (+ multipleOf: 1)
+        - remove 'null' from union type arrays
+        - coerce integer-only enums to number
+        - best-effort simplify oneOf/anyOf when they only differ by integer/number
+        """
+        s = deepcopy(schema)
+
+        def walk(node):  # type: ignore
+            if not isinstance(node, dict):
+                # lists get handled by parent calls
+                return node
+
+            # ---- handle type ----
+            t = node.get("type")
+            if isinstance(t, str):
+                if t == "integer":
+                    node["type"] = "number"
+                    # preserve existing multipleOf but ensure it's integer-like
+                    if "multipleOf" not in node:
+                        node["multipleOf"] = 1
+            elif isinstance(t, list):
+                # remove 'null' (OpenAI tools don't support nullables)
+                t2 = [x if x != "integer" else "number" for x in t if x != "null"]
+                if not t2:
+                    # fall back to object if it somehow becomes empty
+                    t2 = ["object"]
+                node["type"] = t2[0] if len(t2) == 1 else t2
+                if "integer" in t or "number" in t2:
+                    # if integers were present, keep integer-like restriction
+                    node.setdefault("multipleOf", 1)
+
+            # ---- enums of integers -> number ----
+            if "enum" in node and isinstance(node["enum"], list):
+                vals = node["enum"]
+                if vals and all(isinstance(v, int) for v in vals):
+                    node.setdefault("type", "number")
+                    # keep them as ints; JSON 'number' covers ints
+                    node.setdefault("multipleOf", 1)
+
+            # ---- simplify anyOf/oneOf if they only differ by integer/number ----
+            for key in ("oneOf", "anyOf"):
+                if key in node and isinstance(node[key], list):
+                    # Special case: anyOf or oneOf with "type X" and "null"
+                    if len(node[key]) == 2:
+                        types = [sub.get("type") for sub in node[key]]
+                        if "null" in types:
+                            non_null_type = next(t for t in types if t != "null")
+                            if isinstance(non_null_type, str):
+                                node["type"] = non_null_type
+                                node.pop(key, None)
+                                continue
+                    simplified = []
+                    changed = False
+                    for sub in node[key]:
+                        sub = walk(sub)  # recurse
+                        simplified.append(sub)
+                    # If all subs are the same after integer→number, collapse
+                    try:
+                        import json
+
+                        canon = [json.dumps(x, sort_keys=True) for x in simplified]
+                        if len(set(canon)) == 1:
+                            # copy the single schema up
+                            only = simplified[0]
+                            node.pop(key, None)
+                            for k, v in only.items():
+                                if k not in node:
+                                    node[k] = v
+                            changed = True
+                    except Exception:
+                        pass
+                    if not changed:
+                        node[key] = simplified
+
+            # ---- recurse into known schema containers ----
+            for child_key in ("properties", "patternProperties", "definitions", "$defs"):
+                if child_key in node and isinstance(node[child_key], dict):
+                    for k, v in list(node[child_key].items()):
+                        node[child_key][k] = walk(v)
+
+            # arrays/items
+            if "items" in node:
+                node["items"] = walk(node["items"])
+
+            # allOf/if/then/else - pass through with integer→number conversions applied inside
+            for key in ("allOf",):
+                if key in node and isinstance(node[key], list):
+                    node[key] = [walk(x) for x in node[key]]
+
+            if "if" in node:
+                node["if"] = walk(node["if"])
+            if "then" in node:
+                node["then"] = walk(node["then"])
+            if "else" in node:
+                node["else"] = walk(node["else"])
+
+            return node
+
+        return walk(s)
+
+    @staticmethod
+    def make_mcp_tool(tool: Tool, openai_tool_compatible: bool = True) -> MCPTool:
+        """
+        Create an MCP tool from a Serena Tool instance.
+
+        :param tool: The Serena Tool instance to convert.
+        :param openai_tool_compatible: whether to process the tool schema to be compatible with OpenAI tools
+            (doesn't accept integer, needs number instead, etc.). This allows using Serena MCP within codex.
+        """
+        func_name = tool.get_name()
+        func_doc = tool.get_apply_docstring() or ""
+        func_arg_metadata = tool.get_apply_fn_metadata()
+        is_async = False
+        parameters = func_arg_metadata.arg_model.model_json_schema()
+        if openai_tool_compatible:
+            parameters = SerenaMCPFactory._sanitize_for_openai_tools(parameters)
+
+        docstring = docstring_parser.parse(func_doc)
+
+        # Mount the tool description as a combination of the docstring description and
+        # the return value description, if it exists.
+        overridden_description = tool.agent.get_context().tool_description_overrides.get(func_name, None)
+
+        if overridden_description is not None:
+            func_doc = overridden_description
+        elif docstring.description:
+            func_doc = docstring.description
+        else:
+            func_doc = ""
+        func_doc = func_doc.strip().strip(".")
+        if func_doc:
+            func_doc += "."
+        if docstring.returns and (docstring_returns_descr := docstring.returns.description):
+            # Only add a space before "Returns" if func_doc is not empty
+            prefix = " " if func_doc else ""
+            func_doc = f"{func_doc}{prefix}Returns {docstring_returns_descr.strip().strip('.')}."
+
+        # Parse the parameter descriptions from the docstring and add pass its description
+        # to the parameter schema.
+        docstring_params = {param.arg_name: param for param in docstring.params}
+        parameters_properties: dict[str, dict[str, Any]] = parameters["properties"]
+        for parameter, properties in parameters_properties.items():
+            if (param_doc := docstring_params.get(parameter)) and param_doc.description:
+                param_desc = f"{param_doc.description.strip().strip('.') + '.'}"
+                properties["description"] = param_desc[0].upper() + param_desc[1:]
+
+        def execute_fn(**kwargs) -> str:  # type: ignore
+            return tool.apply_ex(log_call=True, catch_exceptions=True, **kwargs)
+
+        return MCPTool(
+            fn=execute_fn,
+            name=func_name,
+            description=func_doc,
+            parameters=parameters,
+            fn_metadata=func_arg_metadata,
+            is_async=is_async,
+            context_kwarg=None,
+            annotations=None,
+            title=None,
+        )
+
+    @abstractmethod
+    def _iter_tools(self) -> Iterator[Tool]:
+        pass
+
+    # noinspection PyProtectedMember
+    def _set_mcp_tools(self, mcp: FastMCP, openai_tool_compatible: bool = False) -> None:
+        """Update the tools in the MCP server"""
+        if mcp is not None:
+            mcp._tool_manager._tools = {}
+            for tool in self._iter_tools():
+                mcp_tool = self.make_mcp_tool(tool, openai_tool_compatible=openai_tool_compatible)
+                mcp._tool_manager._tools[tool.get_name()] = mcp_tool
+            log.info(f"Starting MCP server with {len(mcp._tool_manager._tools)} tools: {list(mcp._tool_manager._tools.keys())}")
+
+    @abstractmethod
+    def _instantiate_agent(self, serena_config: SerenaConfig, modes: list[SerenaAgentMode]) -> None:
+        pass
+
+    def create_mcp_server(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        modes: Sequence[str] = DEFAULT_MODES,
+        enable_web_dashboard: bool | None = None,
+        enable_gui_log_window: bool | None = None,
+        log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = None,
+        trace_lsp_communication: bool | None = None,
+        tool_timeout: float | None = None,
+    ) -> FastMCP:
+        """
+        Create an MCP server with process-isolated SerenaAgent to prevent asyncio contamination.
+
+        :param host: The host to bind to
+        :param port: The port to bind to
+        :param modes: List of mode names or paths to mode files
+        :param enable_web_dashboard: Whether to enable the web dashboard. If not specified, will take the value from the serena configuration.
+        :param enable_gui_log_window: Whether to enable the GUI log window. It currently does not work on macOS, and setting this to True will be ignored then.
+            If not specified, will take the value from the serena configuration.
+        :param log_level: Log level. If not specified, will take the value from the serena configuration.
+        :param trace_lsp_communication: Whether to trace the communication between Serena and the language servers.
+            This is useful for debugging language server issues.
+        :param tool_timeout: Timeout in seconds for tool execution. If not specified, will take the value from the serena configuration.
+        """
+        try:
+            config = SerenaConfig.from_config_file()
+
+            # update configuration with the provided parameters
+            if enable_web_dashboard is not None:
+                config.web_dashboard = enable_web_dashboard
+            if enable_gui_log_window is not None:
+                config.gui_log_window_enabled = enable_gui_log_window
+            if log_level is not None:
+                log_level = cast(Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], log_level.upper())
+                config.log_level = logging.getLevelNamesMapping()[log_level]
+            if trace_lsp_communication is not None:
+                config.trace_lsp_communication = trace_lsp_communication
+            if tool_timeout is not None:
+                config.tool_timeout = tool_timeout
+
+            modes_instances = [SerenaAgentMode.load(mode) for mode in modes]
+            self._instantiate_agent(config, modes_instances)
+
+        except Exception as e:
+            show_fatal_exception_safe(e)
+            raise
+
+        # Override model_config to disable the use of `.env` files for reading settings, because user projects are likely to contain
+        # `.env` files (e.g. containing LOG_LEVEL) that are not supposed to override the MCP settings;
+        # retain only FASTMCP_ prefix for already set environment variables.
+        Settings.model_config = SettingsConfigDict(env_prefix="FASTMCP_")
+        instructions = self._get_initial_instructions()
+        mcp = FastMCP(lifespan=self.server_lifespan, host=host, port=port, instructions=instructions)
+        return mcp
+
+    @asynccontextmanager
+    @abstractmethod
+    async def server_lifespan(self, mcp_server: FastMCP) -> AsyncIterator[None]:
+        """Manage server startup and shutdown lifecycle."""
+        yield None  # ensures MyPy understands we yield None
+
+    @abstractmethod
+    def _get_initial_instructions(self) -> str:
+        pass
+
+
+class SerenaMCPFactorySingleProcess(SerenaMCPFactory):
+    """
+    MCP server factory where the SerenaAgent and its language server run in the same process as the MCP server
+    """
+
+    def __init__(self, context: str = DEFAULT_CONTEXT, project: str | None = None, memory_log_handler: MemoryLogHandler | None = None):
+        """
+        :param context: The context name or path to context file
+        :param project: Either an absolute path to the project directory or a name of an already registered project.
+            If the project passed here hasn't been registered yet, it will be registered automatically and can be activated by its name
+            afterward.
+        """
+        super().__init__(context=context, project=project)
+        self.agent: SerenaAgent | None = None
+        self.memory_log_handler = memory_log_handler
+
+    def _instantiate_agent(self, serena_config: SerenaConfig, modes: list[SerenaAgentMode]) -> None:
+        self.agent = SerenaAgent(
+            project=self.project, serena_config=serena_config, context=self.context, modes=modes, memory_log_handler=self.memory_log_handler
+        )
+
+    def _iter_tools(self) -> Iterator[Tool]:
+        assert self.agent is not None
+        yield from self.agent.get_exposed_tool_instances()
+
+    def _get_initial_instructions(self) -> str:
+        assert self.agent is not None
+        # we don't use the tool (which at the time of writing calls this method), since the tool may be disabled by the config
+        return self.agent.create_system_prompt()
+
+    @asynccontextmanager
+    async def server_lifespan(self, mcp_server: FastMCP) -> AsyncIterator[None]:
+        openai_tool_compatible = self.context.name in ["chatgpt", "codex", "oaicompat-agent"]
+        self._set_mcp_tools(mcp_server, openai_tool_compatible=openai_tool_compatible)
+        log.info("MCP server lifetime setup complete")
+        yield

projects/ui/serena-new/src/serena/project.py

@@ -0,0 +1,306 @@
+import logging
+import os
+from pathlib import Path
+
+import pathspec
+
+from serena.config.serena_config import DEFAULT_TOOL_TIMEOUT, ProjectConfig
+from serena.constants import SERENA_MANAGED_DIR_IN_HOME, SERENA_MANAGED_DIR_NAME
+from serena.text_utils import MatchedConsecutiveLines, search_files
+from serena.util.file_system import GitignoreParser, match_path
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language, LanguageServerConfig
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.settings import SolidLSPSettings
+
+log = logging.getLogger(__name__)
+
+
+class Project:
+    def __init__(self, project_root: str, project_config: ProjectConfig, is_newly_created: bool = False):
+        self.project_root = project_root
+        self.project_config = project_config
+        self.is_newly_created = is_newly_created
+
+        # create .gitignore file in the project's Serena data folder if not yet present
+        serena_data_gitignore_path = os.path.join(self.path_to_serena_data_folder(), ".gitignore")
+        if not os.path.exists(serena_data_gitignore_path):
+            os.makedirs(os.path.dirname(serena_data_gitignore_path), exist_ok=True)
+            log.info(f"Creating .gitignore file in {serena_data_gitignore_path}")
+            with open(serena_data_gitignore_path, "w", encoding="utf-8") as f:
+                f.write(f"/{SolidLanguageServer.CACHE_FOLDER_NAME}\n")
+
+        # gather ignored paths from the project configuration and gitignore files
+        ignored_patterns = project_config.ignored_paths
+        if len(ignored_patterns) > 0:
+            log.info(f"Using {len(ignored_patterns)} ignored paths from the explicit project configuration.")
+            log.debug(f"Ignored paths: {ignored_patterns}")
+        if project_config.ignore_all_files_in_gitignore:
+            gitignore_parser = GitignoreParser(self.project_root)
+            for spec in gitignore_parser.get_ignore_specs():
+                log.debug(f"Adding {len(spec.patterns)} patterns from {spec.file_path} to the ignored paths.")
+                ignored_patterns.extend(spec.patterns)
+        self._ignored_patterns = ignored_patterns
+
+        # Set up the pathspec matcher for the ignored paths
+        # for all absolute paths in ignored_paths, convert them to relative paths
+        processed_patterns = []
+        for pattern in set(ignored_patterns):
+            # Normalize separators (pathspec expects forward slashes)
+            pattern = pattern.replace(os.path.sep, "/")
+            processed_patterns.append(pattern)
+        log.debug(f"Processing {len(processed_patterns)} ignored paths")
+        self._ignore_spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, processed_patterns)
+
+    @property
+    def project_name(self) -> str:
+        return self.project_config.project_name
+
+    @property
+    def language(self) -> Language:
+        return self.project_config.language
+
+    @classmethod
+    def load(cls, project_root: str | Path, autogenerate: bool = True) -> "Project":
+        project_root = Path(project_root).resolve()
+        if not project_root.exists():
+            raise FileNotFoundError(f"Project root not found: {project_root}")
+        project_config = ProjectConfig.load(project_root, autogenerate=autogenerate)
+        return Project(project_root=str(project_root), project_config=project_config)
+
+    def path_to_serena_data_folder(self) -> str:
+        return os.path.join(self.project_root, SERENA_MANAGED_DIR_NAME)
+
+    def path_to_project_yml(self) -> str:
+        return os.path.join(self.project_root, self.project_config.rel_path_to_project_yml())
+
+    def read_file(self, relative_path: str) -> str:
+        """
+        Reads a file relative to the project root.
+
+        :param relative_path: the path to the file relative to the project root
+        :return: the content of the file
+        """
+        abs_path = Path(self.project_root) / relative_path
+        if not abs_path.exists():
+            raise FileNotFoundError(f"File not found: {abs_path}")
+        return abs_path.read_text(encoding=self.project_config.encoding)
+
+    def get_ignore_spec(self) -> pathspec.PathSpec:
+        """
+        :return: the pathspec matcher for the paths that were configured to be ignored,
+            either explicitly or implicitly through .gitignore files.
+        """
+        return self._ignore_spec
+
+    def _is_ignored_relative_path(self, relative_path: str | Path, ignore_non_source_files: bool = True) -> bool:
+        """
+        Determine whether an existing path should be ignored based on file type and ignore patterns.
+        Raises `FileNotFoundError` if the path does not exist.
+
+        :param relative_path: Relative path to check
+        :param ignore_non_source_files: whether files that are not source files (according to the file masks
+            determined by the project's programming language) shall be ignored
+
+        :return: whether the path should be ignored
+        """
+        abs_path = os.path.join(self.project_root, relative_path)
+        if not os.path.exists(abs_path):
+            raise FileNotFoundError(f"File {abs_path} not found, the ignore check cannot be performed")
+
+        # Check file extension if it's a file
+        is_file = os.path.isfile(abs_path)
+        if is_file and ignore_non_source_files:
+            fn_matcher = self.language.get_source_fn_matcher()
+            if not fn_matcher.is_relevant_filename(abs_path):
+                return True
+
+        # Create normalized path for consistent handling
+        rel_path = Path(relative_path)
+
+        # always ignore paths inside .git
+        if len(rel_path.parts) > 0 and rel_path.parts[0] == ".git":
+            return True
+
+        return match_path(str(relative_path), self.get_ignore_spec(), root_path=self.project_root)
+
+    def is_ignored_path(self, path: str | Path, ignore_non_source_files: bool = False) -> bool:
+        """
+        Checks whether the given path is ignored
+
+        :param path: the path to check, can be absolute or relative
+        :param ignore_non_source_files: whether to ignore files that are not source files
+            (according to the file masks determined by the project's programming language)
+        """
+        path = Path(path)
+        if path.is_absolute():
+            try:
+                relative_path = path.relative_to(self.project_root)
+            except ValueError:
+                # If the path is not relative to the project root, we consider it as an absolute path outside the project
+                # (which we ignore)
+                log.warning(f"Path {path} is not relative to the project root {self.project_root} and was therefore ignored")
+                return True
+        else:
+            relative_path = path
+
+        return self._is_ignored_relative_path(str(relative_path), ignore_non_source_files=ignore_non_source_files)
+
+    def is_path_in_project(self, path: str | Path) -> bool:
+        """
+        Checks if the given (absolute or relative) path is inside the project directory.
+        Note that even relative paths may be outside if they contain ".." or point to symlinks.
+        """
+        path = Path(path)
+        _proj_root = Path(self.project_root)
+        if not path.is_absolute():
+            path = _proj_root / path
+
+        path = path.resolve()
+        return path.is_relative_to(_proj_root)
+
+    def relative_path_exists(self, relative_path: str) -> bool:
+        """
+        Checks if the given relative path exists in the project directory.
+
+        :param relative_path: the path to check, relative to the project root
+        :return: True if the path exists, False otherwise
+        """
+        abs_path = Path(self.project_root) / relative_path
+        return abs_path.exists()
+
+    def validate_relative_path(self, relative_path: str) -> None:
+        """
+        Validates that the given relative path to an existing file/dir is safe to read or edit,
+        meaning it's inside the project directory and is not ignored by git.
+
+        Passing a path to a non-existing file will lead to a `FileNotFoundError`.
+        """
+        if not self.is_path_in_project(relative_path):
+            raise ValueError(f"{relative_path=} points to path outside of the repository root; cannot access for safety reasons")
+
+        if self.is_ignored_path(relative_path):
+            raise ValueError(f"Path {relative_path} is ignored; cannot access for safety reasons")
+
+    def gather_source_files(self, relative_path: str = "") -> list[str]:
+        """Retrieves relative paths of all source files, optionally limited to the given path
+
+        :param relative_path: if provided, restrict search to this path
+        """
+        rel_file_paths = []
+        start_path = os.path.join(self.project_root, relative_path)
+        if not os.path.exists(start_path):
+            raise FileNotFoundError(f"Relative path {start_path} not found.")
+        if os.path.isfile(start_path):
+            return [relative_path]
+        else:
+            for root, dirs, files in os.walk(start_path, followlinks=True):
+                # prevent recursion into ignored directories
+                dirs[:] = [d for d in dirs if not self.is_ignored_path(os.path.join(root, d))]
+
+                # collect non-ignored files
+                for file in files:
+                    abs_file_path = os.path.join(root, file)
+                    try:
+                        if not self.is_ignored_path(abs_file_path, ignore_non_source_files=True):
+                            try:
+                                rel_file_path = os.path.relpath(abs_file_path, start=self.project_root)
+                            except Exception:
+                                log.warning(
+                                    "Ignoring path '%s' because it appears to be outside of the project root (%s)",
+                                    abs_file_path,
+                                    self.project_root,
+                                )
+                                continue
+                            rel_file_paths.append(rel_file_path)
+                    except FileNotFoundError:
+                        log.warning(
+                            f"File {abs_file_path} not found (possibly due it being a symlink), skipping it in request_parsed_files",
+                        )
+            return rel_file_paths
+
+    def search_source_files_for_pattern(
+        self,
+        pattern: str,
+        relative_path: str = "",
+        context_lines_before: int = 0,
+        context_lines_after: int = 0,
+        paths_include_glob: str | None = None,
+        paths_exclude_glob: str | None = None,
+    ) -> list[MatchedConsecutiveLines]:
+        """
+        Search for a pattern across all (non-ignored) source files
+
+        :param pattern: Regular expression pattern to search for, either as a compiled Pattern or string
+        :param relative_path:
+        :param context_lines_before: Number of lines of context to include before each match
+        :param context_lines_after: Number of lines of context to include after each match
+        :param paths_include_glob: Glob pattern to filter which files to include in the search
+        :param paths_exclude_glob: Glob pattern to filter which files to exclude from the search. Takes precedence over paths_include_glob.
+        :return: List of matched consecutive lines with context
+        """
+        relative_file_paths = self.gather_source_files(relative_path=relative_path)
+        return search_files(
+            relative_file_paths,
+            pattern,
+            root_path=self.project_root,
+            context_lines_before=context_lines_before,
+            context_lines_after=context_lines_after,
+            paths_include_glob=paths_include_glob,
+            paths_exclude_glob=paths_exclude_glob,
+        )
+
+    def retrieve_content_around_line(
+        self, relative_file_path: str, line: int, context_lines_before: int = 0, context_lines_after: int = 0
+    ) -> MatchedConsecutiveLines:
+        """
+        Retrieve the content of the given file around the given line.
+
+        :param relative_file_path: The relative path of the file to retrieve the content from
+        :param line: The line number to retrieve the content around
+        :param context_lines_before: The number of lines to retrieve before the given line
+        :param context_lines_after: The number of lines to retrieve after the given line
+
+        :return MatchedConsecutiveLines: A container with the desired lines.
+        """
+        file_contents = self.read_file(relative_file_path)
+        return MatchedConsecutiveLines.from_file_contents(
+            file_contents,
+            line=line,
+            context_lines_before=context_lines_before,
+            context_lines_after=context_lines_after,
+            source_file_path=relative_file_path,
+        )
+
+    def create_language_server(
+        self,
+        log_level: int = logging.INFO,
+        ls_timeout: float | None = DEFAULT_TOOL_TIMEOUT - 5,
+        trace_lsp_communication: bool = False,
+    ) -> SolidLanguageServer:
+        """
+        Create a language server for a project. Note that you will have to start it
+        before performing any LS operations.
+
+        :param project: either a path to the project root or a ProjectConfig instance.
+            If no project.yml is found, the default project configuration will be used.
+        :param log_level: the log level for the language server
+        :param ls_timeout: the timeout for the language server
+        :param trace_lsp_communication: whether to trace LSP communication
+        :return: the language server
+        """
+        ls_config = LanguageServerConfig(
+            code_language=self.language,
+            ignored_paths=self._ignored_patterns,
+            trace_lsp_communication=trace_lsp_communication,
+        )
+        ls_logger = LanguageServerLogger(log_level=log_level)
+
+        log.info(f"Creating language server instance for {self.project_root}.")
+        return SolidLanguageServer.create(
+            ls_config,
+            ls_logger,
+            self.project_root,
+            timeout=ls_timeout,
+            solidlsp_settings=SolidLSPSettings(solidlsp_dir=SERENA_MANAGED_DIR_IN_HOME, project_data_relative_path=SERENA_MANAGED_DIR_NAME),
+        )

projects/ui/serena-new/src/serena/prompt_factory.py

@@ -0,0 +1,14 @@
+import os
+
+from serena.constants import PROMPT_TEMPLATES_DIR_IN_USER_HOME, PROMPT_TEMPLATES_DIR_INTERNAL
+from serena.generated.generated_prompt_factory import PromptFactory
+
+
+class SerenaPromptFactory(PromptFactory):
+    """
+    A class for retrieving and rendering prompt templates and prompt lists.
+    """
+
+    def __init__(self) -> None:
+        os.makedirs(PROMPT_TEMPLATES_DIR_IN_USER_HOME, exist_ok=True)
+        super().__init__(prompts_dir=[PROMPT_TEMPLATES_DIR_IN_USER_HOME, PROMPT_TEMPLATES_DIR_INTERNAL])

projects/ui/serena-new/src/serena/symbol.py

@@ -0,0 +1,645 @@
+import json
+import logging
+import os
+from abc import ABC, abstractmethod
+from collections.abc import Iterator, Sequence
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Any, 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
+
+from .project import Project
+
+if TYPE_CHECKING:
+    from .agent import SerenaAgent
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class LanguageServerSymbolLocation:
+    """
+    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, include_relative_path: bool = True) -> dict[str, Any]:
+        result = asdict(self)
+        if not include_relative_path:
+            result.pop("relative_path", None)
+        return result
+
+    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
+
+
+@dataclass
+class PositionInFile:
+    """
+    Represents a character position within a file
+    """
+
+    line: int
+    """
+    the 0-based line number in the file
+    """
+    col: int
+    """
+    the 0-based column
+    """
+
+    def to_lsp_position(self) -> Position:
+        """
+        Convert to LSP Position.
+        """
+        return Position(line=self.line, character=self.col)
+
+
+class Symbol(ABC):
+    @abstractmethod
+    def get_body_start_position(self) -> PositionInFile | None:
+        pass
+
+    @abstractmethod
+    def get_body_end_position(self) -> PositionInFile | None:
+        pass
+
+    def get_body_start_position_or_raise(self) -> PositionInFile:
+        """
+        Get the start position of the symbol body, raising an error if it is not defined.
+        """
+        pos = self.get_body_start_position()
+        if pos is None:
+            raise ValueError(f"Body start position is not defined for {self}")
+        return pos
+
+    def get_body_end_position_or_raise(self) -> PositionInFile:
+        """
+        Get the end position of the symbol body, raising an error if it is not defined.
+        """
+        pos = self.get_body_end_position()
+        if pos is None:
+            raise ValueError(f"Body end position is not defined for {self}")
+        return pos
+
+    @abstractmethod
+    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.
+        """
+
+
+class LanguageServerSymbol(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 = LanguageServerSymbol._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 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) -> LanguageServerSymbolLocation:
+        """
+        :return: the start location of the actual symbol identifier
+        """
+        return LanguageServerSymbolLocation(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_start_position(self) -> PositionInFile | None:
+        start_pos = self.body_start_position
+        if start_pos is None:
+            return None
+        return PositionInFile(line=start_pos["line"], col=start_pos["character"])
+
+    def get_body_end_position(self) -> PositionInFile | None:
+        end_pos = self.body_end_position
+        if end_pos is None:
+            return None
+        return PositionInFile(line=end_pos["line"], col=end_pos["character"])
+
+    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: "LanguageServerSymbol") -> 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 LanguageServerSymbol.match_name_path(
+                name_path=name_path,
+                symbol_name_path_parts=s.get_name_path_parts(),
+                substring_matching=substring_matching,
+            )
+
+        def traverse(s: "LanguageServerSymbol") -> 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,
+        include_relative_path: bool = True,
+    ) -> 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.
+        :param include_relative_path: whether to include the relative path of the symbol in the location
+            entry. Relative paths of the symbol's children are always excluded.
+        :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(include_relative_path=include_relative_path)
+            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,
+                        # all children have the same relative path as the parent
+                        include_relative_path=False,
+                    )
+                )
+            return children
+
+        if depth > 0:
+            result["children"] = add_children(self)
+
+        return result
+
+
+@dataclass
+class ReferenceInLanguageServerSymbol(ToStringMixin):
+    """
+    Represents the location of a reference to another symbol within a symbol/file.
+
+    The contained symbol is the symbol within which the reference is located,
+    not the symbol that is referenced.
+    """
+
+    symbol: LanguageServerSymbol
+    """
+    the symbol within which the reference is located
+    """
+    line: int
+    """
+    the line number in which the reference is located (0-based)
+    """
+    character: int
+    """
+    the column number in which the reference is located (0-based)
+    """
+
+    @classmethod
+    def from_lsp_reference(cls, reference: LSPReferenceInSymbol) -> Self:
+        return cls(symbol=LanguageServerSymbol(reference.symbol), line=reference.line, character=reference.character)
+
+    def get_relative_path(self) -> str | None:
+        return self.symbol.location.relative_path
+
+
+class LanguageServerSymbolRetriever:
+    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 get_language_server(self) -> SolidLanguageServer:
+        return self._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[LanguageServerSymbol]:
+        """
+        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[LanguageServerSymbol] = []
+        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(
+                LanguageServerSymbol(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[LanguageServerSymbol]:
+        symbol_dicts, roots = self._lang_server.request_document_symbols(relative_path, include_body=False)
+        symbols = [LanguageServerSymbol(s) for s in symbol_dicts]
+        return symbols
+
+    def find_by_location(self, location: LanguageServerSymbolLocation) -> LanguageServerSymbol | 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 = LanguageServerSymbol(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[ReferenceInLanguageServerSymbol]:
+        """
+        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: LanguageServerSymbolLocation,
+        include_body: bool = False,
+        include_kinds: Sequence[SymbolKind] | None = None,
+        exclude_kinds: Sequence[SymbolKind] | None = None,
+    ) -> list[ReferenceInLanguageServerSymbol]:
+        """
+        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 [ReferenceInLanguageServerSymbol.from_lsp_reference(r) for r in references]
+
+    @dataclass
+    class SymbolOverviewElement:
+        name_path: str
+        kind: int
+
+        @classmethod
+        def from_symbol(cls, symbol: LanguageServerSymbol) -> Self:
+            return cls(name_path=symbol.get_name_path(), kind=int(symbol.symbol_kind))
+
+    def get_symbol_overview(self, relative_path: str) -> dict[str, list[SymbolOverviewElement]]:
+        path_to_unified_symbols = self._lang_server.request_overview(relative_path)
+        result = {}
+        for file_path, unified_symbols in path_to_unified_symbols.items():
+            # TODO: maybe include not just top-level symbols? We could filter by kind to exclude variables
+            #  The language server methods would need to be adjusted for this.
+            result[file_path] = [self.SymbolOverviewElement.from_symbol(LanguageServerSymbol(s)) for s in unified_symbols]
+        return result
+
+
+class JetBrainsSymbol(Symbol):
+    def __init__(self, symbol_dict: dict, project: Project) -> None:
+        """
+        :param symbol_dict: dictionary as returned by the JetBrains plugin client.
+        """
+        self._project = project
+        self._dict = symbol_dict
+        self._cached_file_content: str | None = None
+        self._cached_body_start_position: PositionInFile | None = None
+        self._cached_body_end_position: PositionInFile | None = None
+
+    def get_relative_path(self) -> str:
+        return self._dict["relative_path"]
+
+    def get_file_content(self) -> str:
+        if self._cached_file_content is None:
+            path = os.path.join(self._project.project_root, self.get_relative_path())
+            with open(path, encoding=self._project.project_config.encoding) as f:
+                self._cached_file_content = f.read()
+        return self._cached_file_content
+
+    def is_position_in_file_available(self) -> bool:
+        return "text_range" in self._dict
+
+    def get_body_start_position(self) -> PositionInFile | None:
+        if not self.is_position_in_file_available():
+            return None
+        if self._cached_body_start_position is None:
+            pos = self._dict["text_range"]["start_pos"]
+            line, col = pos["line"], pos["col"]
+            self._cached_body_start_position = PositionInFile(line=line, col=col)
+        return self._cached_body_start_position
+
+    def get_body_end_position(self) -> PositionInFile | None:
+        if not self.is_position_in_file_available():
+            return None
+        if self._cached_body_end_position is None:
+            pos = self._dict["text_range"]["end_pos"]
+            line, col = pos["line"], pos["col"]
+            self._cached_body_end_position = PositionInFile(line=line, col=col)
+        return self._cached_body_end_position
+
+    def is_neighbouring_definition_separated_by_empty_line(self) -> bool:
+        # NOTE: Symbol types cannot really be differentiated, because types are not handled in a language-agnostic way.
+        return False

projects/ui/serena-new/src/serena/text_utils.py

@@ -0,0 +1,368 @@
+import fnmatch
+import logging
+import os
+import re
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any, Self
+
+from joblib import Parallel, delayed
+
+log = logging.getLogger(__name__)
+
+
+class LineType(StrEnum):
+    """Enum for different types of lines in search results."""
+
+    MATCH = "match"
+    """Part of the matched lines"""
+    BEFORE_MATCH = "prefix"
+    """Lines before the match"""
+    AFTER_MATCH = "postfix"
+    """Lines after the match"""
+
+
+@dataclass(kw_only=True)
+class TextLine:
+    """Represents a line of text with information on how it relates to the match."""
+
+    line_number: int
+    line_content: str
+    match_type: LineType
+    """Represents the type of line (match, prefix, postfix)"""
+
+    def get_display_prefix(self) -> str:
+        """Get the display prefix for this line based on the match type."""
+        if self.match_type == LineType.MATCH:
+            return "  >"
+        return "..."
+
+    def format_line(self, include_line_numbers: bool = True) -> str:
+        """Format the line for display (e.g.,for logging or passing to an LLM).
+
+        :param include_line_numbers: Whether to include the line number in the result.
+        """
+        prefix = self.get_display_prefix()
+        if include_line_numbers:
+            line_num = str(self.line_number).rjust(4)
+            prefix = f"{prefix}{line_num}"
+        return f"{prefix}:{self.line_content}"
+
+
+@dataclass(kw_only=True)
+class MatchedConsecutiveLines:
+    """Represents a collection of consecutive lines found through some criterion in a text file or a string.
+    May include lines before, after, and matched.
+    """
+
+    lines: list[TextLine]
+    """All lines in the context of the match. At least one of them is of `match_type` `MATCH`."""
+    source_file_path: str | None = None
+    """Path to the file where the match was found (Metadata)."""
+
+    # set in post-init
+    lines_before_matched: list[TextLine] = field(default_factory=list)
+    matched_lines: list[TextLine] = field(default_factory=list)
+    lines_after_matched: list[TextLine] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        for line in self.lines:
+            if line.match_type == LineType.BEFORE_MATCH:
+                self.lines_before_matched.append(line)
+            elif line.match_type == LineType.MATCH:
+                self.matched_lines.append(line)
+            elif line.match_type == LineType.AFTER_MATCH:
+                self.lines_after_matched.append(line)
+
+        assert len(self.matched_lines) > 0, "At least one matched line is required"
+
+    @property
+    def start_line(self) -> int:
+        return self.lines[0].line_number
+
+    @property
+    def end_line(self) -> int:
+        return self.lines[-1].line_number
+
+    @property
+    def num_matched_lines(self) -> int:
+        return len(self.matched_lines)
+
+    def to_display_string(self, include_line_numbers: bool = True) -> str:
+        return "\n".join([line.format_line(include_line_numbers) for line in self.lines])
+
+    @classmethod
+    def from_file_contents(
+        cls, file_contents: str, line: int, context_lines_before: int = 0, context_lines_after: int = 0, source_file_path: str | None = None
+    ) -> Self:
+        line_contents = file_contents.split("\n")
+        start_lineno = max(0, line - context_lines_before)
+        end_lineno = min(len(line_contents) - 1, line + context_lines_after)
+        text_lines: list[TextLine] = []
+        # before the line
+        for lineno in range(start_lineno, line):
+            text_lines.append(TextLine(line_number=lineno, line_content=line_contents[lineno], match_type=LineType.BEFORE_MATCH))
+        # the line
+        text_lines.append(TextLine(line_number=line, line_content=line_contents[line], match_type=LineType.MATCH))
+        # after the line
+        for lineno in range(line + 1, end_lineno + 1):
+            text_lines.append(TextLine(line_number=lineno, line_content=line_contents[lineno], match_type=LineType.AFTER_MATCH))
+
+        return cls(lines=text_lines, source_file_path=source_file_path)
+
+
+def glob_to_regex(glob_pat: str) -> str:
+    regex_parts: list[str] = []
+    i = 0
+    while i < len(glob_pat):
+        ch = glob_pat[i]
+        if ch == "*":
+            regex_parts.append(".*")
+        elif ch == "?":
+            regex_parts.append(".")
+        elif ch == "\\":
+            i += 1
+            if i < len(glob_pat):
+                regex_parts.append(re.escape(glob_pat[i]))
+            else:
+                regex_parts.append("\\")
+        else:
+            regex_parts.append(re.escape(ch))
+        i += 1
+    return "".join(regex_parts)
+
+
+def search_text(
+    pattern: str,
+    content: str | None = None,
+    source_file_path: str | None = None,
+    allow_multiline_match: bool = False,
+    context_lines_before: int = 0,
+    context_lines_after: int = 0,
+    is_glob: bool = False,
+) -> list[MatchedConsecutiveLines]:
+    """
+    Search for a pattern in text content. Supports both regex and glob-like patterns.
+
+    :param pattern: Pattern to search for (regex or glob-like pattern)
+    :param content: The text content to search. May be None if source_file_path is provided.
+    :param source_file_path: Optional path to the source file. If content is None,
+        this has to be passed and the file will be read.
+    :param allow_multiline_match: Whether to search across multiple lines. Currently, the default
+        option (False) is very inefficient, so it is recommended to set this to True.
+    :param context_lines_before: Number of context lines to include before matches
+    :param context_lines_after: Number of context lines to include after matches
+    :param is_glob: If True, pattern is treated as a glob-like pattern (e.g., "*.py", "test_??.py")
+             and will be converted to regex internally
+
+    :return: List of `TextSearchMatch` objects
+
+    :raises: ValueError if the pattern is not valid
+
+    """
+    if source_file_path and content is None:
+        with open(source_file_path) as f:
+            content = f.read()
+
+    if content is None:
+        raise ValueError("Pass either content or source_file_path")
+
+    matches = []
+    lines = content.splitlines()
+    total_lines = len(lines)
+
+    # Convert pattern to a compiled regex if it's a string
+    if is_glob:
+        pattern = glob_to_regex(pattern)
+    if allow_multiline_match:
+        # For multiline matches, we need to use the DOTALL flag to make '.' match newlines
+        compiled_pattern = re.compile(pattern, re.DOTALL)
+        # Search across the entire content as a single string
+        for match in compiled_pattern.finditer(content):
+            start_pos = match.start()
+            end_pos = match.end()
+
+            # Find the line numbers for the start and end positions
+            start_line_num = content[:start_pos].count("\n") + 1
+            end_line_num = content[:end_pos].count("\n") + 1
+
+            # Calculate the range of lines to include in the context
+            context_start = max(1, start_line_num - context_lines_before)
+            context_end = min(total_lines, end_line_num + context_lines_after)
+
+            # Create TextLine objects for the context
+            context_lines = []
+            for i in range(context_start - 1, context_end):
+                line_num = i + 1
+                if context_start <= line_num < start_line_num:
+                    match_type = LineType.BEFORE_MATCH
+                elif end_line_num < line_num <= context_end:
+                    match_type = LineType.AFTER_MATCH
+                else:
+                    match_type = LineType.MATCH
+
+                context_lines.append(TextLine(line_number=line_num, line_content=lines[i], match_type=match_type))
+
+            matches.append(MatchedConsecutiveLines(lines=context_lines, source_file_path=source_file_path))
+    else:
+        # TODO: extremely inefficient! Since we currently don't use this option in SerenaAgent or LanguageServer,
+        #   it is not urgent to fix, but should be either improved or the option should be removed.
+        # Search line by line, normal compile without DOTALL
+        compiled_pattern = re.compile(pattern)
+        for i, line in enumerate(lines):
+            line_num = i + 1
+            if compiled_pattern.search(line):
+                # Calculate the range of lines to include in the context
+                context_start = max(0, i - context_lines_before)
+                context_end = min(total_lines - 1, i + context_lines_after)
+
+                # Create TextLine objects for the context
+                context_lines = []
+                for j in range(context_start, context_end + 1):
+                    context_line_num = j + 1
+                    if j < i:
+                        match_type = LineType.BEFORE_MATCH
+                    elif j > i:
+                        match_type = LineType.AFTER_MATCH
+                    else:
+                        match_type = LineType.MATCH
+
+                    context_lines.append(TextLine(line_number=context_line_num, line_content=lines[j], match_type=match_type))
+
+                matches.append(MatchedConsecutiveLines(lines=context_lines, source_file_path=source_file_path))
+
+    return matches
+
+
+def default_file_reader(file_path: str) -> str:
+    """Reads using utf-8 encoding."""
+    with open(file_path, encoding="utf-8") as f:
+        return f.read()
+
+
+def glob_match(pattern: str, path: str) -> bool:
+    """
+    Match a file path against a glob pattern.
+
+    Supports standard glob patterns:
+    - * matches any number of characters except /
+    - ** matches any number of directories (zero or more)
+    - ? matches a single character except /
+    - [seq] matches any character in seq
+
+    :param pattern: Glob pattern (e.g., 'src/**/*.py', '**agent.py')
+    :param path: File path to match against
+    :return: True if path matches pattern
+    """
+    pattern = pattern.replace("\\", "/")  # Normalize backslashes to forward slashes
+    path = path.replace("\\", "/")  # Normalize path backslashes to forward slashes
+
+    # Handle ** patterns that should match zero or more directories
+    if "**" in pattern:
+        # Method 1: Standard fnmatch (matches one or more directories)
+        regex1 = fnmatch.translate(pattern)
+        if re.match(regex1, path):
+            return True
+
+        # Method 2: Handle zero-directory case by removing /** entirely
+        # Convert "src/**/test.py" to "src/test.py"
+        if "/**/" in pattern:
+            zero_dir_pattern = pattern.replace("/**/", "/")
+            regex2 = fnmatch.translate(zero_dir_pattern)
+            if re.match(regex2, path):
+                return True
+
+        # Method 3: Handle leading ** case by removing **/
+        # Convert "**/test.py" to "test.py"
+        if pattern.startswith("**/"):
+            zero_dir_pattern = pattern[3:]  # Remove "**/"
+            regex3 = fnmatch.translate(zero_dir_pattern)
+            if re.match(regex3, path):
+                return True
+
+        return False
+    else:
+        # Simple pattern without **, use fnmatch directly
+        return fnmatch.fnmatch(path, pattern)
+
+
+def search_files(
+    relative_file_paths: list[str],
+    pattern: str,
+    root_path: str = "",
+    file_reader: Callable[[str], str] = default_file_reader,
+    context_lines_before: int = 0,
+    context_lines_after: int = 0,
+    paths_include_glob: str | None = None,
+    paths_exclude_glob: str | None = None,
+) -> list[MatchedConsecutiveLines]:
+    """
+    Search for a pattern in a list of files.
+
+    :param relative_file_paths: List of relative file paths in which to search
+    :param pattern: Pattern to search for
+    :param root_path: Root path to resolve relative paths against (by default, current working directory).
+    :param file_reader: Function to read a file, by default will just use os.open.
+        All files that can't be read by it will be skipped.
+    :param context_lines_before: Number of context lines to include before matches
+    :param context_lines_after: Number of context lines to include after matches
+    :param paths_include_glob: Optional glob pattern to include files from the list
+    :param paths_exclude_glob: Optional glob pattern to exclude files from the list
+    :return: List of MatchedConsecutiveLines objects
+    """
+    # Pre-filter paths (done sequentially to avoid overhead)
+    # Use proper glob matching instead of gitignore patterns
+    filtered_paths = []
+    for path in relative_file_paths:
+        if paths_include_glob and not glob_match(paths_include_glob, path):
+            log.debug(f"Skipping {path}: does not match include pattern {paths_include_glob}")
+            continue
+        if paths_exclude_glob and glob_match(paths_exclude_glob, path):
+            log.debug(f"Skipping {path}: matches exclude pattern {paths_exclude_glob}")
+            continue
+        filtered_paths.append(path)
+
+    log.info(f"Processing {len(filtered_paths)} files.")
+
+    def process_single_file(path: str) -> dict[str, Any]:
+        """Process a single file - this function will be parallelized."""
+        try:
+            abs_path = os.path.join(root_path, path)
+            file_content = file_reader(abs_path)
+            search_results = search_text(
+                pattern,
+                content=file_content,
+                source_file_path=path,
+                allow_multiline_match=True,
+                context_lines_before=context_lines_before,
+                context_lines_after=context_lines_after,
+            )
+            if len(search_results) > 0:
+                log.debug(f"Found {len(search_results)} matches in {path}")
+            return {"path": path, "results": search_results, "error": None}
+        except Exception as e:
+            log.debug(f"Error processing {path}: {e}")
+            return {"path": path, "results": [], "error": str(e)}
+
+    # Execute in parallel using joblib
+    results = Parallel(
+        n_jobs=-1,
+        backend="threading",
+    )(delayed(process_single_file)(path) for path in filtered_paths)
+
+    # Collect results and errors
+    matches = []
+    skipped_file_error_tuples = []
+
+    for result in results:
+        if result["error"]:
+            skipped_file_error_tuples.append((result["path"], result["error"]))
+        else:
+            matches.extend(result["results"])
+
+    if skipped_file_error_tuples:
+        log.debug(f"Failed to read {len(skipped_file_error_tuples)} files: {skipped_file_error_tuples}")
+
+    log.info(f"Found {len(matches)} total matches across {len(filtered_paths)} files")
+    return matches

projects/ui/serena-new/src/solidlsp/.gitignore

@@ -0,0 +1 @@
+language_servers/static

projects/ui/serena-new/src/solidlsp/__init__.py

@@ -0,0 +1,2 @@
+# ruff: noqa
+from .ls import SolidLanguageServer

projects/ui/serena-new/src/solidlsp/ls.py

@@ -0,0 +1,1738 @@
+import dataclasses
+import hashlib
+import json
+import logging
+import os
+import pathlib
+import pickle
+import shutil
+import subprocess
+import threading
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from collections.abc import Iterator
+from contextlib import contextmanager
+from copy import copy
+from pathlib import Path, PurePath
+from time import sleep
+from typing import Self, Union, cast
+
+import pathspec
+
+from serena.text_utils import MatchedConsecutiveLines
+from serena.util.file_system import match_path
+from solidlsp import ls_types
+from solidlsp.ls_config import Language, LanguageServerConfig
+from solidlsp.ls_exceptions import SolidLSPException
+from solidlsp.ls_handler import SolidLanguageServerHandler
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.ls_types import UnifiedSymbolInformation
+from solidlsp.ls_utils import FileUtils, PathUtils, TextUtils
+from solidlsp.lsp_protocol_handler import lsp_types
+from solidlsp.lsp_protocol_handler import lsp_types as LSPTypes
+from solidlsp.lsp_protocol_handler.lsp_constants import LSPConstants
+from solidlsp.lsp_protocol_handler.lsp_types import Definition, DefinitionParams, LocationLink, SymbolKind
+from solidlsp.lsp_protocol_handler.server import (
+    LSPError,
+    ProcessLaunchInfo,
+    StringDict,
+)
+from solidlsp.settings import SolidLSPSettings
+
+GenericDocumentSymbol = Union[LSPTypes.DocumentSymbol, LSPTypes.SymbolInformation, ls_types.UnifiedSymbolInformation]
+
+
+@dataclasses.dataclass(kw_only=True)
+class ReferenceInSymbol:
+    """A symbol retrieved when requesting reference to a symbol, together with the location of the reference"""
+
+    symbol: ls_types.UnifiedSymbolInformation
+    line: int
+    character: int
+
+
+@dataclasses.dataclass
+class LSPFileBuffer:
+    """
+    This class is used to store the contents of an open LSP file in memory.
+    """
+
+    # uri of the file
+    uri: str
+
+    # The contents of the file
+    contents: str
+
+    # The version of the file
+    version: int
+
+    # The language id of the file
+    language_id: str
+
+    # reference count of the file
+    ref_count: int
+
+    content_hash: str = ""
+
+    def __post_init__(self):
+        self.content_hash = hashlib.md5(self.contents.encode("utf-8")).hexdigest()
+
+
+class SolidLanguageServer(ABC):
+    """
+    The LanguageServer class provides a language agnostic interface to the Language Server Protocol.
+    It is used to communicate with Language Servers of different programming languages.
+    """
+
+    CACHE_FOLDER_NAME = "cache"
+
+    # To be overridden and extended by subclasses
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        """
+        A language-specific condition for directories that should always be ignored. For example, venv
+        in Python and node_modules in JS/TS should be ignored always.
+        """
+        return dirname.startswith(".")
+
+    @classmethod
+    def ls_resources_dir(cls, solidlsp_settings: SolidLSPSettings, mkdir: bool = True) -> str:
+        """
+        Returns the directory where the language server resources are downloaded.
+        This is used to store language server binaries, configuration files, etc.
+        """
+        result = os.path.join(solidlsp_settings.ls_resources_dir, cls.__name__)
+
+        # Migration of previously downloaded LS resources that were downloaded to a subdir of solidlsp instead of to the user's home
+        pre_migration_ls_resources_dir = os.path.join(os.path.dirname(__file__), "language_servers", "static", cls.__name__)
+        if os.path.exists(pre_migration_ls_resources_dir):
+            if os.path.exists(result):
+                # if the directory already exists, we just remove the old resources
+                shutil.rmtree(result, ignore_errors=True)
+            else:
+                # move old resources to the new location
+                shutil.move(pre_migration_ls_resources_dir, result)
+        if mkdir:
+            os.makedirs(result, exist_ok=True)
+        return result
+
+    @classmethod
+    def create(
+        cls,
+        config: LanguageServerConfig,
+        logger: LanguageServerLogger,
+        repository_root_path: str,
+        timeout: float | None = None,
+        solidlsp_settings: SolidLSPSettings | None = None,
+    ) -> "SolidLanguageServer":
+        """
+        Creates a language specific LanguageServer instance based on the given configuration, and appropriate settings for the programming language.
+
+        If language is Java, then ensure that jdk-17.0.6 or higher is installed, `java` is in PATH, and JAVA_HOME is set to the installation directory.
+        If language is JS/TS, then ensure that node (v18.16.0 or higher) is installed and in PATH.
+
+        :param repository_root_path: The root path of the repository.
+        :param config: The Multilspy configuration.
+        :param logger: The logger to use.
+        :param timeout: the timeout for requests to the language server. If None, no timeout will be used.
+        :return LanguageServer: A language specific LanguageServer instance.
+        """
+        ls: SolidLanguageServer
+        if solidlsp_settings is None:
+            solidlsp_settings = SolidLSPSettings()
+
+        if config.code_language == Language.PYTHON:
+            from solidlsp.language_servers.pyright_server import (
+                PyrightServer,
+            )
+
+            ls = PyrightServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+        elif config.code_language == Language.PYTHON_JEDI:
+            from solidlsp.language_servers.jedi_server import JediServer
+
+            ls = JediServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+        elif config.code_language == Language.JAVA:
+            from solidlsp.language_servers.eclipse_jdtls import (
+                EclipseJDTLS,
+            )
+
+            ls = EclipseJDTLS(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.KOTLIN:
+            from solidlsp.language_servers.kotlin_language_server import (
+                KotlinLanguageServer,
+            )
+
+            ls = KotlinLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.RUST:
+            from solidlsp.language_servers.rust_analyzer import (
+                RustAnalyzer,
+            )
+
+            ls = RustAnalyzer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.CSHARP:
+            from solidlsp.language_servers.csharp_language_server import CSharpLanguageServer
+
+            ls = CSharpLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+        elif config.code_language == Language.CSHARP_OMNISHARP:
+            from solidlsp.language_servers.omnisharp import OmniSharp
+
+            ls = OmniSharp(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+        elif config.code_language == Language.TYPESCRIPT:
+            from solidlsp.language_servers.typescript_language_server import (
+                TypeScriptLanguageServer,
+            )
+
+            ls = TypeScriptLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+        elif config.code_language == Language.TYPESCRIPT_VTS:
+            # VTS based Language Server implementation, need to experiment to see if it improves performance
+            from solidlsp.language_servers.vts_language_server import VtsLanguageServer
+
+            ls = VtsLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+        elif config.code_language == Language.GO:
+            from solidlsp.language_servers.gopls import Gopls
+
+            ls = Gopls(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.RUBY:
+            from solidlsp.language_servers.ruby_lsp import RubyLsp
+
+            ls = RubyLsp(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.RUBY_SOLARGRAPH:
+            from solidlsp.language_servers.solargraph import Solargraph
+
+            ls = Solargraph(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.DART:
+            from solidlsp.language_servers.dart_language_server import DartLanguageServer
+
+            ls = DartLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.CPP:
+            from solidlsp.language_servers.clangd_language_server import ClangdLanguageServer
+
+            ls = ClangdLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.PHP:
+            from solidlsp.language_servers.intelephense import Intelephense
+
+            ls = Intelephense(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.R:
+            from solidlsp.language_servers.r_language_server import RLanguageServer
+
+            ls = RLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.CLOJURE:
+            from solidlsp.language_servers.clojure_lsp import ClojureLSP
+
+            ls = ClojureLSP(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.ELIXIR:
+            from solidlsp.language_servers.elixir_tools.elixir_tools import ElixirTools
+
+            ls = ElixirTools(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.TERRAFORM:
+            from solidlsp.language_servers.terraform_ls import TerraformLS
+
+            ls = TerraformLS(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.SWIFT:
+            from solidlsp.language_servers.sourcekit_lsp import SourceKitLSP
+
+            ls = SourceKitLSP(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.BASH:
+            from solidlsp.language_servers.bash_language_server import BashLanguageServer
+
+            ls = BashLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.ZIG:
+            from solidlsp.language_servers.zls import ZigLanguageServer
+
+            ls = ZigLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.NIX:
+            from solidlsp.language_servers.nixd_ls import NixLanguageServer
+
+            ls = NixLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.LUA:
+            from solidlsp.language_servers.lua_ls import LuaLanguageServer
+
+            ls = LuaLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        elif config.code_language == Language.ERLANG:
+            from solidlsp.language_servers.erlang_language_server import ErlangLanguageServer
+
+            ls = ErlangLanguageServer(config, logger, repository_root_path, solidlsp_settings=solidlsp_settings)
+
+        else:
+            logger.log(f"Language {config.code_language} is not supported", logging.ERROR)
+            raise SolidLSPException(f"Language {config.code_language} is not supported")
+
+        ls.set_request_timeout(timeout)
+        return ls
+
+    def __init__(
+        self,
+        config: LanguageServerConfig,
+        logger: LanguageServerLogger,
+        repository_root_path: str,
+        process_launch_info: ProcessLaunchInfo,
+        language_id: str,
+        solidlsp_settings: SolidLSPSettings,
+    ):
+        """
+        Initializes a LanguageServer instance.
+
+        Do not instantiate this class directly. Use `LanguageServer.create` method instead.
+
+        :param config: The Multilspy configuration.
+        :param logger: The logger to use.
+        :param repository_root_path: The root path of the repository.
+        :param process_launch_info: Each language server has a specific command used to start the server.
+                    This parameter is the command to launch the language server process.
+                    The command must pass appropriate flags to the binary, so that it runs in the stdio mode,
+                    as opposed to HTTP, TCP modes supported by some language servers.
+        """
+        self._solidlsp_settings = solidlsp_settings
+        self.logger = logger
+        self.repository_root_path: str = repository_root_path
+        self.logger.log(
+            f"Creating language server instance for {repository_root_path=} with {language_id=} and process launch info: {process_launch_info}",
+            logging.DEBUG,
+        )
+
+        self.language_id = language_id
+        self.open_file_buffers: dict[str, LSPFileBuffer] = {}
+        self.language = Language(language_id)
+
+        # load cache first to prevent any racing conditions due to asyncio stuff
+        self._document_symbols_cache: dict[
+            str, tuple[str, tuple[list[ls_types.UnifiedSymbolInformation], list[ls_types.UnifiedSymbolInformation]]]
+        ] = {}
+        """Maps file paths to a tuple of (file_content_hash, result_of_request_document_symbols)"""
+        self._cache_lock = threading.Lock()
+        self._cache_has_changed: bool = False
+        self.load_cache()
+
+        self.server_started = False
+        self.completions_available = threading.Event()
+        if config.trace_lsp_communication:
+
+            def logging_fn(source: str, target: str, msg: StringDict | str):
+                self.logger.log(f"LSP: {source} -> {target}: {msg!s}", self.logger.logger.level)
+
+        else:
+            logging_fn = None
+
+        # cmd is obtained from the child classes, which provide the language specific command to start the language server
+        # LanguageServerHandler provides the functionality to start the language server and communicate with it
+        self.logger.log(
+            f"Creating language server instance with {language_id=} and process launch info: {process_launch_info}", logging.DEBUG
+        )
+        self.server = SolidLanguageServerHandler(
+            process_launch_info,
+            logger=logging_fn,
+            start_independent_lsp_process=config.start_independent_lsp_process,
+        )
+
+        # Set up the pathspec matcher for the ignored paths
+        # for all absolute paths in ignored_paths, convert them to relative paths
+        processed_patterns = []
+        for pattern in set(config.ignored_paths):
+            # Normalize separators (pathspec expects forward slashes)
+            pattern = pattern.replace(os.path.sep, "/")
+            processed_patterns.append(pattern)
+        self.logger.log(f"Processing {len(processed_patterns)} ignored paths from the config", logging.DEBUG)
+
+        # Create a pathspec matcher from the processed patterns
+        self._ignore_spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, processed_patterns)
+
+        self._server_context = None
+        self._request_timeout: float | None = None
+
+        self._has_waited_for_cross_file_references = False
+
+    def _get_wait_time_for_cross_file_referencing(self) -> float:
+        """Meant to be overridden by subclasses for LS that don't have a reliable "finished initializing" signal.
+
+        LS may return incomplete results on calls to `request_references` (only references found in the same file),
+        if the LS is not fully initialized yet.
+        """
+        return 2
+
+    def set_request_timeout(self, timeout: float | None) -> None:
+        """
+        :param timeout: the timeout, in seconds, for requests to the language server.
+        """
+        self.server.set_request_timeout(timeout)
+
+    def get_ignore_spec(self) -> pathspec.PathSpec:
+        """Returns the pathspec matcher for the paths that were configured to be ignored through
+        the multilspy config.
+
+        This is is a subset of the full language-specific ignore spec that determines
+        which files are relevant for the language server.
+
+        This matcher is useful for operations outside of the language server,
+        such as when searching for relevant non-language files in the project.
+        """
+        return self._ignore_spec
+
+    def is_ignored_path(self, relative_path: str, ignore_unsupported_files: bool = True) -> bool:
+        """
+        Determine if a path should be ignored based on file type
+        and ignore patterns.
+
+        :param relative_path: Relative path to check
+        :param ignore_unsupported_files: whether files that are not supported source files should be ignored
+
+        :return: True if the path should be ignored, False otherwise
+        """
+        abs_path = os.path.join(self.repository_root_path, relative_path)
+        if not os.path.exists(abs_path):
+            raise FileNotFoundError(f"File {abs_path} not found, the ignore check cannot be performed")
+
+        # Check file extension if it's a file
+        is_file = os.path.isfile(abs_path)
+        if is_file and ignore_unsupported_files:
+            fn_matcher = self.language.get_source_fn_matcher()
+            if not fn_matcher.is_relevant_filename(abs_path):
+                return True
+
+        # Create normalized path for consistent handling
+        rel_path = Path(relative_path)
+
+        # Check each part of the path against always fulfilled ignore conditions
+        dir_parts = rel_path.parts
+        if is_file:
+            dir_parts = dir_parts[:-1]
+        for part in dir_parts:
+            if not part:  # Skip empty parts (e.g., from leading '/')
+                continue
+            if self.is_ignored_dirname(part):
+                return True
+
+        return match_path(relative_path, self.get_ignore_spec(), root_path=self.repository_root_path)
+
+    def _shutdown(self, timeout: float = 5.0):
+        """
+        A robust shutdown process designed to terminate cleanly on all platforms, including Windows,
+        by explicitly closing all I/O pipes.
+        """
+        if not self.server.is_running():
+            self.logger.log("Server process not running, skipping shutdown.", logging.DEBUG)
+            return
+
+        self.logger.log(f"Initiating final robust shutdown with a {timeout}s timeout...", logging.INFO)
+        process = self.server.process
+
+        # --- Main Shutdown Logic ---
+        # Stage 1: Graceful Termination Request
+        # Send LSP shutdown and close stdin to signal no more input.
+        try:
+            self.logger.log("Sending LSP shutdown request...", logging.DEBUG)
+            # Use a thread to timeout the LSP shutdown call since it can hang
+            shutdown_thread = threading.Thread(target=self.server.shutdown)
+            shutdown_thread.daemon = True
+            shutdown_thread.start()
+            shutdown_thread.join(timeout=2.0)  # 2 second timeout for LSP shutdown
+
+            if shutdown_thread.is_alive():
+                self.logger.log("LSP shutdown request timed out, proceeding to terminate...", logging.DEBUG)
+            else:
+                self.logger.log("LSP shutdown request completed.", logging.DEBUG)
+
+            if process.stdin and not process.stdin.is_closing():
+                process.stdin.close()
+            self.logger.log("Stage 1 shutdown complete.", logging.DEBUG)
+        except Exception as e:
+            self.logger.log(f"Exception during graceful shutdown: {e}", logging.DEBUG)
+            # Ignore errors here, we are proceeding to terminate anyway.
+
+        # Stage 2: Terminate and Wait for Process to Exit
+        self.logger.log(f"Terminating process {process.pid}, current status: {process.poll()}", logging.DEBUG)
+        process.terminate()
+
+        # Stage 3: Wait for process termination with timeout
+        try:
+            self.logger.log(f"Waiting for process {process.pid} to terminate...", logging.DEBUG)
+            exit_code = process.wait(timeout=timeout)
+            self.logger.log(f"Language server process terminated successfully with exit code {exit_code}.", logging.INFO)
+        except subprocess.TimeoutExpired:
+            # If termination failed, forcefully kill the process
+            self.logger.log(f"Process {process.pid} termination timed out, killing process forcefully...", logging.WARNING)
+            process.kill()
+            try:
+                exit_code = process.wait(timeout=2.0)
+                self.logger.log(f"Language server process killed successfully with exit code {exit_code}.", logging.INFO)
+            except subprocess.TimeoutExpired:
+                self.logger.log(f"Process {process.pid} could not be killed within timeout.", logging.ERROR)
+        except Exception as e:
+            self.logger.log(f"Error during process shutdown: {e}", logging.ERROR)
+
+    @contextmanager
+    def start_server(self) -> Iterator["SolidLanguageServer"]:
+        self.start()
+        yield self
+        self.stop()
+
+    def _start_server_process(self) -> None:
+        self.server_started = True
+        self._start_server()
+
+    @abstractmethod
+    def _start_server(self):
+        pass
+
+    @contextmanager
+    def open_file(self, relative_file_path: str) -> Iterator[LSPFileBuffer]:
+        """
+        Open a file in the Language Server. This is required before making any requests to the Language Server.
+
+        :param relative_file_path: The relative path of the file to open.
+        """
+        if not self.server_started:
+            self.logger.log(
+                "open_file called before Language Server started",
+                logging.ERROR,
+            )
+            raise SolidLSPException("Language Server not started")
+
+        absolute_file_path = str(PurePath(self.repository_root_path, relative_file_path))
+        uri = pathlib.Path(absolute_file_path).as_uri()
+
+        if uri in self.open_file_buffers:
+            assert self.open_file_buffers[uri].uri == uri
+            assert self.open_file_buffers[uri].ref_count >= 1
+
+            self.open_file_buffers[uri].ref_count += 1
+            yield self.open_file_buffers[uri]
+            self.open_file_buffers[uri].ref_count -= 1
+        else:
+            contents = FileUtils.read_file(self.logger, absolute_file_path)
+
+            version = 0
+            self.open_file_buffers[uri] = LSPFileBuffer(uri, contents, version, self.language_id, 1)
+
+            self.server.notify.did_open_text_document(
+                {
+                    LSPConstants.TEXT_DOCUMENT: {
+                        LSPConstants.URI: uri,
+                        LSPConstants.LANGUAGE_ID: self.language_id,
+                        LSPConstants.VERSION: 0,
+                        LSPConstants.TEXT: contents,
+                    }
+                }
+            )
+            yield self.open_file_buffers[uri]
+            self.open_file_buffers[uri].ref_count -= 1
+
+        if self.open_file_buffers[uri].ref_count == 0:
+            self.server.notify.did_close_text_document(
+                {
+                    LSPConstants.TEXT_DOCUMENT: {
+                        LSPConstants.URI: uri,
+                    }
+                }
+            )
+            del self.open_file_buffers[uri]
+
+    def insert_text_at_position(self, relative_file_path: str, line: int, column: int, text_to_be_inserted: str) -> ls_types.Position:
+        """
+        Insert text at the given line and column in the given file and return
+        the updated cursor position after inserting the text.
+
+        :param relative_file_path: The relative path of the file to open.
+        :param line: The line number at which text should be inserted.
+        :param column: The column number at which text should be inserted.
+        :param text_to_be_inserted: The text to insert.
+        """
+        if not self.server_started:
+            self.logger.log(
+                "insert_text_at_position called before Language Server started",
+                logging.ERROR,
+            )
+            raise SolidLSPException("Language Server not started")
+
+        absolute_file_path = str(PurePath(self.repository_root_path, relative_file_path))
+        uri = pathlib.Path(absolute_file_path).as_uri()
+
+        # Ensure the file is open
+        assert uri in self.open_file_buffers
+
+        file_buffer = self.open_file_buffers[uri]
+        file_buffer.version += 1
+
+        new_contents, new_l, new_c = TextUtils.insert_text_at_position(file_buffer.contents, line, column, text_to_be_inserted)
+        file_buffer.contents = new_contents
+        self.server.notify.did_change_text_document(
+            {
+                LSPConstants.TEXT_DOCUMENT: {
+                    LSPConstants.VERSION: file_buffer.version,
+                    LSPConstants.URI: file_buffer.uri,
+                },
+                LSPConstants.CONTENT_CHANGES: [
+                    {
+                        LSPConstants.RANGE: {
+                            "start": {"line": line, "character": column},
+                            "end": {"line": line, "character": column},
+                        },
+                        "text": text_to_be_inserted,
+                    }
+                ],
+            }
+        )
+        return ls_types.Position(line=new_l, character=new_c)
+
+    def delete_text_between_positions(
+        self,
+        relative_file_path: str,
+        start: ls_types.Position,
+        end: ls_types.Position,
+    ) -> str:
+        """
+        Delete text between the given start and end positions in the given file and return the deleted text.
+        """
+        if not self.server_started:
+            self.logger.log(
+                "insert_text_at_position called before Language Server started",
+                logging.ERROR,
+            )
+            raise SolidLSPException("Language Server not started")
+
+        absolute_file_path = str(PurePath(self.repository_root_path, relative_file_path))
+        uri = pathlib.Path(absolute_file_path).as_uri()
+
+        # Ensure the file is open
+        assert uri in self.open_file_buffers
+
+        file_buffer = self.open_file_buffers[uri]
+        file_buffer.version += 1
+        new_contents, deleted_text = TextUtils.delete_text_between_positions(
+            file_buffer.contents, start_line=start["line"], start_col=start["character"], end_line=end["line"], end_col=end["character"]
+        )
+        file_buffer.contents = new_contents
+        self.server.notify.did_change_text_document(
+            {
+                LSPConstants.TEXT_DOCUMENT: {
+                    LSPConstants.VERSION: file_buffer.version,
+                    LSPConstants.URI: file_buffer.uri,
+                },
+                LSPConstants.CONTENT_CHANGES: [{LSPConstants.RANGE: {"start": start, "end": end}, "text": ""}],
+            }
+        )
+        return deleted_text
+
+    def _send_definition_request(self, definition_params: DefinitionParams) -> Definition | list[LocationLink] | None:
+        return self.server.send.definition(definition_params)
+
+    def request_definition(self, relative_file_path: str, line: int, column: int) -> list[ls_types.Location]:
+        """
+        Raise a [textDocument/definition](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_definition) request to the Language Server
+        for the symbol at the given line and column in the given file. Wait for the response and return the result.
+
+        :param relative_file_path: The relative path of the file that has the symbol for which definition should be looked up
+        :param line: The line number of the symbol
+        :param column: The column number of the symbol
+
+        :return List[multilspy_types.Location]: A list of locations where the symbol is defined
+        """
+        if not self.server_started:
+            self.logger.log(
+                "request_definition called before Language Server started",
+                logging.ERROR,
+            )
+            raise SolidLSPException("Language Server not started")
+
+        if not self._has_waited_for_cross_file_references:
+            # Some LS require waiting for a while before they can return cross-file definitions.
+            # This is a workaround for such LS that don't have a reliable "finished initializing" signal.
+            sleep(self._get_wait_time_for_cross_file_referencing())
+            self._has_waited_for_cross_file_references = True
+
+        with self.open_file(relative_file_path):
+            # sending request to the language server and waiting for response
+            definition_params = cast(
+                DefinitionParams,
+                {
+                    LSPConstants.TEXT_DOCUMENT: {
+                        LSPConstants.URI: pathlib.Path(str(PurePath(self.repository_root_path, relative_file_path))).as_uri()
+                    },
+                    LSPConstants.POSITION: {
+                        LSPConstants.LINE: line,
+                        LSPConstants.CHARACTER: column,
+                    },
+                },
+            )
+            response = self._send_definition_request(definition_params)
+
+        ret: list[ls_types.Location] = []
+        if isinstance(response, list):
+            # response is either of type Location[] or LocationLink[]
+            for item in response:
+                assert isinstance(item, dict)
+                if LSPConstants.URI in item and LSPConstants.RANGE in item:
+                    new_item: ls_types.Location = {}
+                    new_item.update(item)
+                    new_item["absolutePath"] = PathUtils.uri_to_path(new_item["uri"])
+                    new_item["relativePath"] = PathUtils.get_relative_path(new_item["absolutePath"], self.repository_root_path)
+                    ret.append(ls_types.Location(new_item))
+                elif LSPConstants.TARGET_URI in item and LSPConstants.TARGET_RANGE in item and LSPConstants.TARGET_SELECTION_RANGE in item:
+                    new_item: ls_types.Location = {}
+                    new_item["uri"] = item[LSPConstants.TARGET_URI]
+                    new_item["absolutePath"] = PathUtils.uri_to_path(new_item["uri"])
+                    new_item["relativePath"] = PathUtils.get_relative_path(new_item["absolutePath"], self.repository_root_path)
+                    new_item["range"] = item[LSPConstants.TARGET_SELECTION_RANGE]
+                    ret.append(ls_types.Location(**new_item))
+                else:
+                    assert False, f"Unexpected response from Language Server: {item}"
+        elif isinstance(response, dict):
+            # response is of type Location
+            assert LSPConstants.URI in response
+            assert LSPConstants.RANGE in response
+
+            new_item: ls_types.Location = {}
+            new_item.update(response)
+            new_item["absolutePath"] = PathUtils.uri_to_path(new_item["uri"])
+            new_item["relativePath"] = PathUtils.get_relative_path(new_item["absolutePath"], self.repository_root_path)
+            ret.append(ls_types.Location(**new_item))
+        elif response is None:
+            # Some language servers return None when they cannot find a definition
+            # This is expected for certain symbol types like generics or types with incomplete information
+            self.logger.log(
+                f"Language server returned None for definition request at {relative_file_path}:{line}:{column}",
+                logging.WARNING,
+            )
+        else:
+            assert False, f"Unexpected response from Language Server: {response}"
+
+        return ret
+
+    # Some LS cause problems with this, so the call is isolated from the rest to allow overriding in subclasses
+    def _send_references_request(self, relative_file_path: str, line: int, column: int) -> list[lsp_types.Location] | None:
+        return self.server.send.references(
+            {
+                "textDocument": {"uri": PathUtils.path_to_uri(os.path.join(self.repository_root_path, relative_file_path))},
+                "position": {"line": line, "character": column},
+                "context": {"includeDeclaration": False},
+            }
+        )
+
+    def request_references(self, relative_file_path: str, line: int, column: int) -> list[ls_types.Location]:
+        """
+        Raise a [textDocument/references](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_references) request to the Language Server
+        to find references to the symbol at the given line and column in the given file. Wait for the response and return the result.
+        Filters out references located in ignored directories.
+
+        :param relative_file_path: The relative path of the file that has the symbol for which references should be looked up
+        :param line: The line number of the symbol
+        :param column: The column number of the symbol
+
+        :return: A list of locations where the symbol is referenced (excluding ignored directories)
+        """
+        if not self.server_started:
+            self.logger.log(
+                "request_references called before Language Server started",
+                logging.ERROR,
+            )
+            raise SolidLSPException("Language Server not started")
+
+        if not self._has_waited_for_cross_file_references:
+            # Some LS require waiting for a while before they can return cross-file references.
+            # This is a workaround for such LS that don't have a reliable "finished initializing" signal.
+            sleep(self._get_wait_time_for_cross_file_referencing())
+            self._has_waited_for_cross_file_references = True
+
+        with self.open_file(relative_file_path):
+            try:
+                response = self._send_references_request(relative_file_path, line=line, column=column)
+            except Exception as e:
+                # Catch LSP internal error (-32603) and raise a more informative exception
+                if isinstance(e, LSPError) and getattr(e, "code", None) == -32603:
+                    raise RuntimeError(
+                        f"LSP internal error (-32603) when requesting references for {relative_file_path}:{line}:{column}. "
+                        "This often occurs when requesting references for a symbol not referenced in the expected way. "
+                    ) from e
+                raise
+        if response is None:
+            return []
+
+        ret: list[ls_types.Location] = []
+        assert isinstance(response, list), f"Unexpected response from Language Server (expected list, got {type(response)}): {response}"
+        for item in response:
+            assert isinstance(item, dict), f"Unexpected response from Language Server (expected dict, got {type(item)}): {item}"
+            assert LSPConstants.URI in item
+            assert LSPConstants.RANGE in item
+
+            abs_path = PathUtils.uri_to_path(item[LSPConstants.URI])
+            if not Path(abs_path).is_relative_to(self.repository_root_path):
+                self.logger.log(
+                    "Found a reference in a path outside the repository, probably the LS is parsing things in installed packages or in the standardlib! "
+                    f"Path: {abs_path}. This is a bug but we currently simply skip these references.",
+                    logging.WARNING,
+                )
+                continue
+
+            rel_path = Path(abs_path).relative_to(self.repository_root_path)
+            if self.is_ignored_path(str(rel_path)):
+                self.logger.log(f"Ignoring reference in {rel_path} since it should be ignored", logging.DEBUG)
+                continue
+
+            new_item: ls_types.Location = {}
+            new_item.update(item)
+            new_item["absolutePath"] = str(abs_path)
+            new_item["relativePath"] = str(rel_path)
+            ret.append(ls_types.Location(**new_item))
+
+        return ret
+
+    def request_text_document_diagnostics(self, relative_file_path: str) -> list[ls_types.Diagnostic]:
+        """
+        Raise a [textDocument/diagnostic](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_diagnostic) request to the Language Server
+        to find diagnostics for the given file. Wait for the response and return the result.
+
+        :param relative_file_path: The relative path of the file to retrieve diagnostics for
+
+        :return: A list of diagnostics for the file
+        """
+        if not self.server_started:
+            self.logger.log(
+                "request_text_document_diagnostics called before Language Server started",
+                logging.ERROR,
+            )
+            raise SolidLSPException("Language Server not started")
+
+        with self.open_file(relative_file_path):
+            response = self.server.send.text_document_diagnostic(
+                {
+                    LSPConstants.TEXT_DOCUMENT: {
+                        LSPConstants.URI: pathlib.Path(str(PurePath(self.repository_root_path, relative_file_path))).as_uri()
+                    }
+                }
+            )
+
+        if response is None:
+            return []
+
+        assert isinstance(response, dict), f"Unexpected response from Language Server (expected list, got {type(response)}): {response}"
+        ret: list[ls_types.Diagnostic] = []
+        for item in response["items"]:
+            new_item: ls_types.Diagnostic = {
+                "uri": pathlib.Path(str(PurePath(self.repository_root_path, relative_file_path))).as_uri(),
+                "severity": item["severity"],
+                "message": item["message"],
+                "range": item["range"],
+                "code": item["code"],
+            }
+            ret.append(ls_types.Diagnostic(new_item))
+
+        return ret
+
+    def retrieve_full_file_content(self, file_path: str) -> str:
+        """
+        Retrieve the full content of the given file.
+        """
+        if os.path.isabs(file_path):
+            file_path = os.path.relpath(file_path, self.repository_root_path)
+        with self.open_file(file_path) as file_data:
+            return file_data.contents
+
+    def retrieve_content_around_line(
+        self, relative_file_path: str, line: int, context_lines_before: int = 0, context_lines_after: int = 0
+    ) -> MatchedConsecutiveLines:
+        """
+        Retrieve the content of the given file around the given line.
+
+        :param relative_file_path: The relative path of the file to retrieve the content from
+        :param line: The line number to retrieve the content around
+        :param context_lines_before: The number of lines to retrieve before the given line
+        :param context_lines_after: The number of lines to retrieve after the given line
+
+        :return MatchedConsecutiveLines: A container with the desired lines.
+        """
+        with self.open_file(relative_file_path) as file_data:
+            file_contents = file_data.contents
+        return MatchedConsecutiveLines.from_file_contents(
+            file_contents,
+            line=line,
+            context_lines_before=context_lines_before,
+            context_lines_after=context_lines_after,
+            source_file_path=relative_file_path,
+        )
+
+    def request_completions(
+        self, relative_file_path: str, line: int, column: int, allow_incomplete: bool = False
+    ) -> list[ls_types.CompletionItem]:
+        """
+        Raise a [textDocument/completion](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion) request to the Language Server
+        to find completions at the given line and column in the given file. Wait for the response and return the result.
+
+        :param relative_file_path: The relative path of the file that has the symbol for which completions should be looked up
+        :param line: The line number of the symbol
+        :param column: The column number of the symbol
+
+        :return List[multilspy_types.CompletionItem]: A list of completions
+        """
+        with self.open_file(relative_file_path):
+            open_file_buffer = self.open_file_buffers[pathlib.Path(os.path.join(self.repository_root_path, relative_file_path)).as_uri()]
+            completion_params: LSPTypes.CompletionParams = {
+                "position": {"line": line, "character": column},
+                "textDocument": {"uri": open_file_buffer.uri},
+                "context": {"triggerKind": LSPTypes.CompletionTriggerKind.Invoked},
+            }
+            response: list[LSPTypes.CompletionItem] | LSPTypes.CompletionList | None = None
+
+            num_retries = 0
+            while response is None or (response["isIncomplete"] and num_retries < 30):
+                self.completions_available.wait()
+                response: list[LSPTypes.CompletionItem] | LSPTypes.CompletionList | None = self.server.send.completion(completion_params)
+                if isinstance(response, list):
+                    response = {"items": response, "isIncomplete": False}
+                num_retries += 1
+
+            # TODO: Understand how to appropriately handle `isIncomplete`
+            if response is None or (response["isIncomplete"] and not (allow_incomplete)):
+                return []
+
+            if "items" in response:
+                response = response["items"]
+
+            response = cast(list[LSPTypes.CompletionItem], response)
+
+            # TODO: Handle the case when the completion is a keyword
+            items = [item for item in response if item["kind"] != LSPTypes.CompletionItemKind.Keyword]
+
+            completions_list: list[ls_types.CompletionItem] = []
+
+            for item in items:
+                assert "insertText" in item or "textEdit" in item
+                assert "kind" in item
+                completion_item = {}
+                if "detail" in item:
+                    completion_item["detail"] = item["detail"]
+
+                if "label" in item:
+                    completion_item["completionText"] = item["label"]
+                    completion_item["kind"] = item["kind"]
+                elif "insertText" in item:
+                    completion_item["completionText"] = item["insertText"]
+                    completion_item["kind"] = item["kind"]
+                elif "textEdit" in item and "newText" in item["textEdit"]:
+                    completion_item["completionText"] = item["textEdit"]["newText"]
+                    completion_item["kind"] = item["kind"]
+                elif "textEdit" in item and "range" in item["textEdit"]:
+                    new_dot_lineno, new_dot_colno = (
+                        completion_params["position"]["line"],
+                        completion_params["position"]["character"],
+                    )
+                    assert all(
+                        (
+                            item["textEdit"]["range"]["start"]["line"] == new_dot_lineno,
+                            item["textEdit"]["range"]["start"]["character"] == new_dot_colno,
+                            item["textEdit"]["range"]["start"]["line"] == item["textEdit"]["range"]["end"]["line"],
+                            item["textEdit"]["range"]["start"]["character"] == item["textEdit"]["range"]["end"]["character"],
+                        )
+                    )
+
+                    completion_item["completionText"] = item["textEdit"]["newText"]
+                    completion_item["kind"] = item["kind"]
+                elif "textEdit" in item and "insert" in item["textEdit"]:
+                    assert False
+                else:
+                    assert False
+
+                completion_item = ls_types.CompletionItem(**completion_item)
+                completions_list.append(completion_item)
+
+            return [json.loads(json_repr) for json_repr in set(json.dumps(item, sort_keys=True) for item in completions_list)]
+
+    def request_document_symbols(
+        self, relative_file_path: str, include_body: bool = False
+    ) -> tuple[list[ls_types.UnifiedSymbolInformation], list[ls_types.UnifiedSymbolInformation]]:
+        """
+        Raise a [textDocument/documentSymbol](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_documentSymbol) request to the Language Server
+        to find symbols in the given file. Wait for the response and return the result.
+
+        :param relative_file_path: The relative path of the file that has the symbols
+        :param include_body: whether to include the body of the symbols in the result.
+        :return: A list of symbols in the file, and a list of root symbols that represent the tree structure of the symbols.
+            All symbols will have a location, a children, and a parent attribute,
+            where the parent attribute is None for root symbols.
+            Note that this is slightly different from the call to request_full_symbol_tree,
+            where the parent attribute will be the file symbol which in turn may have a package symbol as parent.
+            If you need a symbol tree that contains file symbols as well, you should use `request_full_symbol_tree` instead.
+        """
+        # TODO: it's kinda dumb to not use the cache if include_body is False after include_body was True once
+        #   Should be fixed in the future, it's a small performance optimization
+        cache_key = f"{relative_file_path}-{include_body}"
+        with self.open_file(relative_file_path) as file_data:
+            with self._cache_lock:
+                file_hash_and_result = self._document_symbols_cache.get(cache_key)
+                if file_hash_and_result is not None:
+                    file_hash, result = file_hash_and_result
+                    if file_hash == file_data.content_hash:
+                        self.logger.log(f"Returning cached document symbols for {relative_file_path}", logging.DEBUG)
+                        return result
+                    else:
+                        self.logger.log(f"Content for {relative_file_path} has changed. Will overwrite in-memory cache", logging.DEBUG)
+                else:
+                    self.logger.log(f"No cache hit for symbols with {include_body=} in {relative_file_path}", logging.DEBUG)
+
+            self.logger.log(f"Requesting document symbols for {relative_file_path} from the Language Server", logging.DEBUG)
+            response = self.server.send.document_symbol(
+                {"textDocument": {"uri": pathlib.Path(os.path.join(self.repository_root_path, relative_file_path)).as_uri()}}
+            )
+            if response is None:
+                self.logger.log(
+                    f"Received None response from the Language Server for document symbols in {relative_file_path}. "
+                    f"This means the language server can't understand this file (possibly due to syntax errors). It may also be due to a bug or misconfiguration of the LS. "
+                    f"Returning empty list",
+                    logging.WARNING,
+                )
+                return [], []
+            assert isinstance(response, list), f"Unexpected response from Language Server: {response}"
+            self.logger.log(
+                f"Received {len(response)} document symbols for {relative_file_path} from the Language Server",
+                logging.DEBUG,
+            )
+
+        def turn_item_into_symbol_with_children(item: GenericDocumentSymbol):
+            item = cast(ls_types.UnifiedSymbolInformation, item)
+            absolute_path = os.path.join(self.repository_root_path, relative_file_path)
+
+            # handle missing entries in location
+            if "location" not in item:
+                uri = pathlib.Path(absolute_path).as_uri()
+                assert "range" in item
+                tree_location = ls_types.Location(
+                    uri=uri,
+                    range=item["range"],
+                    absolutePath=absolute_path,
+                    relativePath=relative_file_path,
+                )
+                item["location"] = tree_location
+            location = item["location"]
+            if "absolutePath" not in location:
+                location["absolutePath"] = absolute_path
+            if "relativePath" not in location:
+                location["relativePath"] = relative_file_path
+            if include_body:
+                item["body"] = self.retrieve_symbol_body(item)
+            # handle missing selectionRange
+            if "selectionRange" not in item:
+                if "range" in item:
+                    item["selectionRange"] = item["range"]
+                else:
+                    item["selectionRange"] = item["location"]["range"]
+            children = item.get(LSPConstants.CHILDREN, [])
+            for child in children:
+                child["parent"] = item
+            item[LSPConstants.CHILDREN] = children
+
+        flat_all_symbol_list: list[ls_types.UnifiedSymbolInformation] = []
+        root_nodes: list[ls_types.UnifiedSymbolInformation] = []
+        for root_item in response:
+            if "range" not in root_item and "location" not in root_item:
+                if root_item["kind"] in [SymbolKind.File, SymbolKind.Module]:
+                    ...
+
+            # mutation is more convenient than creating a new dict,
+            # so we cast and rename the var after the mutating call to turn_item_into_symbol_with_children
+            # which turned and item into a "symbol"
+            turn_item_into_symbol_with_children(root_item)
+            root_symbol = cast(ls_types.UnifiedSymbolInformation, root_item)
+            root_symbol["parent"] = None
+
+            root_nodes.append(root_symbol)
+            assert isinstance(root_symbol, dict)
+            assert LSPConstants.NAME in root_symbol
+            assert LSPConstants.KIND in root_symbol
+
+            if LSPConstants.CHILDREN in root_symbol:
+                # TODO: l_tree should be a list of TreeRepr. Define the following function to return TreeRepr as well
+
+                def visit_tree_nodes_and_build_tree_repr(node: GenericDocumentSymbol) -> list[ls_types.UnifiedSymbolInformation]:
+                    node = cast(ls_types.UnifiedSymbolInformation, node)
+                    l: list[ls_types.UnifiedSymbolInformation] = []
+                    turn_item_into_symbol_with_children(node)
+                    assert LSPConstants.CHILDREN in node
+                    children = node[LSPConstants.CHILDREN]
+                    l.append(node)
+                    for child in children:
+                        l.extend(visit_tree_nodes_and_build_tree_repr(child))
+                    return l
+
+                flat_all_symbol_list.extend(visit_tree_nodes_and_build_tree_repr(root_symbol))
+            else:
+                flat_all_symbol_list.append(ls_types.UnifiedSymbolInformation(**root_symbol))
+
+        result = flat_all_symbol_list, root_nodes
+        self.logger.log(f"Caching document symbols for {relative_file_path}", logging.DEBUG)
+        with self._cache_lock:
+            self._document_symbols_cache[cache_key] = (file_data.content_hash, result)
+            self._cache_has_changed = True
+        return result
+
+    def request_full_symbol_tree(
+        self, within_relative_path: str | None = None, include_body: bool = False
+    ) -> list[ls_types.UnifiedSymbolInformation]:
+        """
+        Will go through all files in the project or within a relative path and build a tree of symbols.
+        Note: this may be slow the first time it is called, especially if `within_relative_path` is not used to restrict the search.
+
+        For each file, a symbol of kind File (2) will be created. For directories, a symbol of kind Package (4) will be created.
+        All symbols will have a children attribute, thereby representing the tree structure of all symbols in the project
+        that are within the repository.
+        All symbols except the root packages will have a parent attribute.
+        Will ignore directories starting with '.', language-specific defaults
+        and user-configured directories (e.g. from .gitignore).
+
+        :param within_relative_path: pass a relative path to only consider symbols within this path.
+            If a file is passed, only the symbols within this file will be considered.
+            If a directory is passed, all files within this directory will be considered.
+        :param include_body: whether to include the body of the symbols in the result.
+
+        :return: A list of root symbols representing the top-level packages/modules in the project.
+        """
+        if within_relative_path is not None:
+            within_abs_path = os.path.join(self.repository_root_path, within_relative_path)
+            if not os.path.exists(within_abs_path):
+                raise FileNotFoundError(f"File or directory not found: {within_abs_path}")
+            if os.path.isfile(within_abs_path):
+                if self.is_ignored_path(within_relative_path):
+                    self.logger.log(
+                        f"You passed a file explicitly, but it is ignored. This is probably an error. File: {within_relative_path}",
+                        logging.ERROR,
+                    )
+                    return []
+                else:
+                    _, root_nodes = self.request_document_symbols(within_relative_path, include_body=include_body)
+                    return root_nodes
+
+        # Helper function to recursively process directories
+        def process_directory(rel_dir_path: str) -> list[ls_types.UnifiedSymbolInformation]:
+            abs_dir_path = self.repository_root_path if rel_dir_path == "." else os.path.join(self.repository_root_path, rel_dir_path)
+            abs_dir_path = os.path.realpath(abs_dir_path)
+
+            if self.is_ignored_path(str(Path(abs_dir_path).relative_to(self.repository_root_path))):
+                self.logger.log(f"Skipping directory: {rel_dir_path}\n(because it should be ignored)", logging.DEBUG)
+                return []
+
+            result = []
+            try:
+                contained_dir_or_file_names = os.listdir(abs_dir_path)
+            except OSError:
+                return []
+
+            # Create package symbol for directory
+            package_symbol = ls_types.UnifiedSymbolInformation(  # type: ignore
+                name=os.path.basename(abs_dir_path),
+                kind=ls_types.SymbolKind.Package,
+                location=ls_types.Location(
+                    uri=str(pathlib.Path(abs_dir_path).as_uri()),
+                    range={"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}},
+                    absolutePath=str(abs_dir_path),
+                    relativePath=str(Path(abs_dir_path).resolve().relative_to(self.repository_root_path)),
+                ),
+                children=[],
+            )
+            result.append(package_symbol)
+
+            for contained_dir_or_file_name in contained_dir_or_file_names:
+                contained_dir_or_file_abs_path = os.path.join(abs_dir_path, contained_dir_or_file_name)
+                contained_dir_or_file_rel_path = str(Path(contained_dir_or_file_abs_path).resolve().relative_to(self.repository_root_path))
+                if self.is_ignored_path(contained_dir_or_file_rel_path):
+                    self.logger.log(f"Skipping item: {contained_dir_or_file_rel_path}\n(because it should be ignored)", logging.DEBUG)
+                    continue
+
+                if os.path.isdir(contained_dir_or_file_abs_path):
+                    child_symbols = process_directory(contained_dir_or_file_rel_path)
+                    package_symbol["children"].extend(child_symbols)
+                    for child in child_symbols:
+                        child["parent"] = package_symbol
+
+                elif os.path.isfile(contained_dir_or_file_abs_path):
+                    _, file_root_nodes = self.request_document_symbols(contained_dir_or_file_rel_path, include_body=include_body)
+
+                    # Create file symbol, link with children
+                    file_rel_path = str(Path(contained_dir_or_file_abs_path).resolve().relative_to(self.repository_root_path))
+                    with self.open_file(file_rel_path) as file_data:
+                        fileRange = self._get_range_from_file_content(file_data.contents)
+                    file_symbol = ls_types.UnifiedSymbolInformation(  # type: ignore
+                        name=os.path.splitext(contained_dir_or_file_name)[0],
+                        kind=ls_types.SymbolKind.File,
+                        range=fileRange,
+                        selectionRange=fileRange,
+                        location=ls_types.Location(
+                            uri=str(pathlib.Path(contained_dir_or_file_abs_path).as_uri()),
+                            range=fileRange,
+                            absolutePath=str(contained_dir_or_file_abs_path),
+                            relativePath=str(Path(contained_dir_or_file_abs_path).resolve().relative_to(self.repository_root_path)),
+                        ),
+                        children=file_root_nodes,
+                        parent=package_symbol,
+                    )
+                    for child in file_root_nodes:
+                        child["parent"] = file_symbol
+
+                    # Link file symbol with package
+                    package_symbol["children"].append(file_symbol)
+
+                    # TODO: Not sure if this is actually still needed given recent changes to relative path handling
+                    def fix_relative_path(nodes: list[ls_types.UnifiedSymbolInformation]):
+                        for node in nodes:
+                            if "location" in node and "relativePath" in node["location"]:
+                                path = Path(node["location"]["relativePath"])
+                                if path.is_absolute():
+                                    try:
+                                        path = path.relative_to(self.repository_root_path)
+                                        node["location"]["relativePath"] = str(path)
+                                    except Exception:
+                                        pass
+                            if "children" in node:
+                                fix_relative_path(node["children"])
+
+                    fix_relative_path(file_root_nodes)
+
+            return result
+
+        # Start from the root or the specified directory
+        start_rel_path = within_relative_path or "."
+        return process_directory(start_rel_path)
+
+    @staticmethod
+    def _get_range_from_file_content(file_content: str) -> ls_types.Range:
+        """
+        Get the range for the given file.
+        """
+        lines = file_content.split("\n")
+        end_line = len(lines)
+        end_column = len(lines[-1])
+        return ls_types.Range(start=ls_types.Position(line=0, character=0), end=ls_types.Position(line=end_line, character=end_column))
+
+    def request_dir_overview(self, relative_dir_path: str) -> dict[str, list[UnifiedSymbolInformation]]:
+        """
+        :return: A mapping of all relative paths analyzed to lists of top-level symbols in the corresponding file.
+        """
+        symbol_tree = self.request_full_symbol_tree(relative_dir_path)
+        # Initialize result dictionary
+        result: dict[str, list[UnifiedSymbolInformation]] = defaultdict(list)
+
+        # Helper function to process a symbol and its children
+        def process_symbol(symbol: ls_types.UnifiedSymbolInformation):
+            if symbol["kind"] == ls_types.SymbolKind.File:
+                # For file symbols, process their children (top-level symbols)
+                for child in symbol["children"]:
+                    path = Path(child["location"]["absolutePath"]).resolve().relative_to(self.repository_root_path)
+                    result[str(path)].append(child)
+            # For package/directory symbols, process their children
+            for child in symbol["children"]:
+                process_symbol(child)
+
+        # Process each root symbol
+        for root in symbol_tree:
+            process_symbol(root)
+        return result
+
+    def request_document_overview(self, relative_file_path: str) -> list[UnifiedSymbolInformation]:
+        """
+        :return: the top-level symbols in the given file.
+        """
+        _, document_roots = self.request_document_symbols(relative_file_path)
+        return document_roots
+
+    def request_overview(self, within_relative_path: str) -> dict[str, list[UnifiedSymbolInformation]]:
+        """
+        An overview of all symbols in the given file or directory.
+
+        :param within_relative_path: the relative path to the file or directory to get the overview of.
+        :return: A mapping of all relative paths analyzed to lists of top-level symbols in the corresponding file.
+        """
+        abs_path = (Path(self.repository_root_path) / within_relative_path).resolve()
+        if not abs_path.exists():
+            raise FileNotFoundError(f"File or directory not found: {abs_path}")
+
+        if abs_path.is_file():
+            symbols_overview = self.request_document_overview(within_relative_path)
+            return {within_relative_path: symbols_overview}
+        else:
+            return self.request_dir_overview(within_relative_path)
+
+    def request_hover(self, relative_file_path: str, line: int, column: int) -> ls_types.Hover | None:
+        """
+        Raise a [textDocument/hover](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_hover) request to the Language Server
+        to find the hover information at the given line and column in the given file. Wait for the response and return the result.
+
+        :param relative_file_path: The relative path of the file that has the hover information
+        :param line: The line number of the symbol
+        :param column: The column number of the symbol
+
+        :return None
+        """
+        with self.open_file(relative_file_path):
+            response = self.server.send.hover(
+                {
+                    "textDocument": {"uri": pathlib.Path(os.path.join(self.repository_root_path, relative_file_path)).as_uri()},
+                    "position": {
+                        "line": line,
+                        "character": column,
+                    },
+                }
+            )
+
+        if response is None:
+            return None
+
+        assert isinstance(response, dict)
+
+        return ls_types.Hover(**response)
+
+    def retrieve_symbol_body(self, symbol: ls_types.UnifiedSymbolInformation | LSPTypes.DocumentSymbol | LSPTypes.SymbolInformation) -> str:
+        """
+        Load the body of the given symbol. If the body is already contained in the symbol, just return it.
+        """
+        existing_body = symbol.get("body", None)
+        if existing_body:
+            return existing_body
+
+        assert "location" in symbol
+        symbol_start_line = symbol["location"]["range"]["start"]["line"]
+        symbol_end_line = symbol["location"]["range"]["end"]["line"]
+        assert "relativePath" in symbol["location"]
+        symbol_file = self.retrieve_full_file_content(symbol["location"]["relativePath"])
+        symbol_lines = symbol_file.split("\n")
+        symbol_body = "\n".join(symbol_lines[symbol_start_line : symbol_end_line + 1])
+
+        # remove leading indentation
+        symbol_start_column = symbol["location"]["range"]["start"]["character"]
+        symbol_body = symbol_body[symbol_start_column:]
+        return symbol_body
+
+    def request_referencing_symbols(
+        self,
+        relative_file_path: str,
+        line: int,
+        column: int,
+        include_imports: bool = True,
+        include_self: bool = False,
+        include_body: bool = False,
+        include_file_symbols: bool = False,
+    ) -> list[ReferenceInSymbol]:
+        """
+        Finds all symbols that reference the symbol at the given location.
+        This is similar to request_references but filters to only include symbols
+        (functions, methods, classes, etc.) that reference the target symbol.
+
+        :param relative_file_path: The relative path to the file.
+        :param line: The 0-indexed line number.
+        :param column: The 0-indexed column number.
+        :param include_imports: whether to also include imports as references.
+            Unfortunately, the LSP does not have an import type, so the references corresponding to imports
+            will not be easily distinguishable from definitions.
+        :param include_self: whether to include the references that is the "input symbol" itself.
+            Only has an effect if the relative_file_path, line and column point to a symbol, for example a definition.
+        :param include_body: whether to include the body of the symbols in the result.
+        :param include_file_symbols: whether to include references that are file symbols. This
+            is often a fallback mechanism for when the reference cannot be resolved to a symbol.
+        :return: List of objects containing the symbol and the location of the reference.
+        """
+        if not self.server_started:
+            self.logger.log(
+                "request_referencing_symbols called before Language Server started",
+                logging.ERROR,
+            )
+            raise SolidLSPException("Language Server not started")
+
+        # First, get all references to the symbol
+        references = self.request_references(relative_file_path, line, column)
+        if not references:
+            return []
+
+        # For each reference, find the containing symbol
+        result = []
+        incoming_symbol = None
+        for ref in references:
+            ref_path = ref["relativePath"]
+            ref_line = ref["range"]["start"]["line"]
+            ref_col = ref["range"]["start"]["character"]
+
+            with self.open_file(ref_path) as file_data:
+                # Get the containing symbol for this reference
+                containing_symbol = self.request_containing_symbol(ref_path, ref_line, ref_col, include_body=include_body)
+                if containing_symbol is None:
+                    # TODO: HORRIBLE HACK! I don't know how to do it better for now...
+                    # THIS IS BOUND TO BREAK IN MANY CASES! IT IS ALSO SPECIFIC TO PYTHON!
+                    # Background:
+                    # When a variable is used to change something, like
+                    #
+                    # instance = MyClass()
+                    # instance.status = "new status"
+                    #
+                    # we can't find the containing symbol for the reference to `status`
+                    # since there is no container on the line of the reference
+                    # The hack is to try to find a variable symbol in the containing module
+                    # by using the text of the reference to find the variable name (In a very heuristic way)
+                    # and then look for a symbol with that name and kind Variable
+                    ref_text = file_data.contents.split("\n")[ref_line]
+                    if "." in ref_text:
+                        containing_symbol_name = ref_text.split(".")[0]
+                        all_symbols, _ = self.request_document_symbols(ref_path)
+                        for symbol in all_symbols:
+                            if symbol["name"] == containing_symbol_name and symbol["kind"] == ls_types.SymbolKind.Variable:
+                                containing_symbol = copy(symbol)
+                                containing_symbol["location"] = ref
+                                containing_symbol["range"] = ref["range"]
+                                break
+
+                # We failed retrieving the symbol, falling back to creating a file symbol
+                if containing_symbol is None and include_file_symbols:
+                    self.logger.log(
+                        f"Could not find containing symbol for {ref_path}:{ref_line}:{ref_col}. Returning file symbol instead",
+                        logging.WARNING,
+                    )
+                    fileRange = self._get_range_from_file_content(file_data.contents)
+                    location = ls_types.Location(
+                        uri=str(pathlib.Path(os.path.join(self.repository_root_path, ref_path)).as_uri()),
+                        range=fileRange,
+                        absolutePath=str(os.path.join(self.repository_root_path, ref_path)),
+                        relativePath=ref_path,
+                    )
+                    name = os.path.splitext(os.path.basename(ref_path))[0]
+
+                    if include_body:
+                        body = self.retrieve_full_file_content(ref_path)
+                    else:
+                        body = ""
+
+                    containing_symbol = ls_types.UnifiedSymbolInformation(
+                        kind=ls_types.SymbolKind.File,
+                        range=fileRange,
+                        selectionRange=fileRange,
+                        location=location,
+                        name=name,
+                        children=[],
+                        body=body,
+                    )
+                if containing_symbol is None or (not include_file_symbols and containing_symbol["kind"] == ls_types.SymbolKind.File):
+                    continue
+
+                assert "location" in containing_symbol
+                assert "selectionRange" in containing_symbol
+
+                # Checking for self-reference
+                if (
+                    containing_symbol["location"]["relativePath"] == relative_file_path
+                    and containing_symbol["selectionRange"]["start"]["line"] == ref_line
+                    and containing_symbol["selectionRange"]["start"]["character"] == ref_col
+                ):
+                    incoming_symbol = containing_symbol
+                    if include_self:
+                        result.append(ReferenceInSymbol(symbol=containing_symbol, line=ref_line, character=ref_col))
+                        continue
+                    self.logger.log(f"Found self-reference for {incoming_symbol['name']}, skipping it since {include_self=}", logging.DEBUG)
+                    continue
+
+                # checking whether reference is an import
+                # This is neither really safe nor elegant, but if we don't do it,
+                # there is no way to distinguish between definitions and imports as import is not a symbol-type
+                # and we get the type referenced symbol resulting from imports...
+                if (
+                    not include_imports
+                    and incoming_symbol is not None
+                    and containing_symbol["name"] == incoming_symbol["name"]
+                    and containing_symbol["kind"] == incoming_symbol["kind"]
+                ):
+                    self.logger.log(
+                        f"Found import of referenced symbol {incoming_symbol['name']}"
+                        f"in {containing_symbol['location']['relativePath']}, skipping",
+                        logging.DEBUG,
+                    )
+                    continue
+
+                result.append(ReferenceInSymbol(symbol=containing_symbol, line=ref_line, character=ref_col))
+
+        return result
+
+    def request_containing_symbol(
+        self,
+        relative_file_path: str,
+        line: int,
+        column: int | None = None,
+        strict: bool = False,
+        include_body: bool = False,
+    ) -> ls_types.UnifiedSymbolInformation | None:
+        """
+        Finds the first symbol containing the position for the given file.
+        For Python, container symbols are considered to be those with kinds corresponding to
+        functions, methods, or classes (typically: Function (12), Method (6), Class (5)).
+
+        The method operates as follows:
+          - Request the document symbols for the file.
+          - Filter symbols to those that start at or before the given line.
+          - From these, first look for symbols whose range contains the (line, column).
+          - If one or more symbols contain the position, return the one with the greatest starting position
+            (i.e. the innermost container).
+          - If none (strictly) contain the position, return the symbol with the greatest starting position
+            among those above the given line.
+          - If no container candidates are found, return None.
+
+        :param relative_file_path: The relative path to the Python file.
+        :param line: The 0-indexed line number.
+        :param column: The 0-indexed column (also called character). If not passed, the lookup will be based
+            only on the line.
+        :param strict: If True, the position must be strictly within the range of the symbol.
+            Setting to True is useful for example for finding the parent of a symbol, as with strict=False,
+            and the line pointing to a symbol itself, the containing symbol will be the symbol itself
+            (and not the parent).
+        :param include_body: Whether to include the body of the symbol in the result.
+        :return: The container symbol (if found) or None.
+        """
+        # checking if the line is empty, unfortunately ugly and duplicating code, but I don't want to refactor
+        with self.open_file(relative_file_path):
+            absolute_file_path = str(PurePath(self.repository_root_path, relative_file_path))
+            content = FileUtils.read_file(self.logger, absolute_file_path)
+            if content.split("\n")[line].strip() == "":
+                self.logger.log(
+                    f"Passing empty lines to request_container_symbol is currently not supported, {relative_file_path=}, {line=}",
+                    logging.ERROR,
+                )
+                return None
+
+        symbols, _ = self.request_document_symbols(relative_file_path)
+
+        # make jedi and pyright api compatible
+        # the former has no location, the later has no range
+        # we will just always add location of the desired format to all symbols
+        for symbol in symbols:
+            if "location" not in symbol:
+                range = symbol["range"]
+                location = ls_types.Location(
+                    uri=f"file:/{absolute_file_path}",
+                    range=range,
+                    absolutePath=absolute_file_path,
+                    relativePath=relative_file_path,
+                )
+                symbol["location"] = location
+            else:
+                location = symbol["location"]
+                assert "range" in location
+                location["absolutePath"] = absolute_file_path
+                location["relativePath"] = relative_file_path
+                location["uri"] = Path(absolute_file_path).as_uri()
+
+        # Allowed container kinds, currently only for Python
+        container_symbol_kinds = {ls_types.SymbolKind.Method, ls_types.SymbolKind.Function, ls_types.SymbolKind.Class}
+
+        def is_position_in_range(line: int, range_d: ls_types.Range) -> bool:
+            start = range_d["start"]
+            end = range_d["end"]
+
+            column_condition = True
+            if strict:
+                line_condition = end["line"] >= line > start["line"]
+                if column is not None and line == start["line"]:
+                    column_condition = column > start["character"]
+            else:
+                line_condition = end["line"] >= line >= start["line"]
+                if column is not None and line == start["line"]:
+                    column_condition = column >= start["character"]
+            return line_condition and column_condition
+
+        # Only consider containers that are not one-liners (otherwise we may get imports)
+        candidate_containers = [
+            s
+            for s in symbols
+            if s["kind"] in container_symbol_kinds and s["location"]["range"]["start"]["line"] != s["location"]["range"]["end"]["line"]
+        ]
+        var_containers = [s for s in symbols if s["kind"] == ls_types.SymbolKind.Variable]
+        candidate_containers.extend(var_containers)
+
+        if not candidate_containers:
+            return None
+
+        # From the candidates, find those whose range contains the given position.
+        containing_symbols = []
+        for symbol in candidate_containers:
+            s_range = symbol["location"]["range"]
+            if not is_position_in_range(line, s_range):
+                continue
+            containing_symbols.append(symbol)
+
+        if containing_symbols:
+            # Return the one with the greatest starting position (i.e. the innermost container).
+            containing_symbol = max(containing_symbols, key=lambda s: s["location"]["range"]["start"]["line"])
+            if include_body:
+                containing_symbol["body"] = self.retrieve_symbol_body(containing_symbol)
+            return containing_symbol
+        else:
+            return None
+
+    def request_container_of_symbol(
+        self, symbol: ls_types.UnifiedSymbolInformation, include_body: bool = False
+    ) -> ls_types.UnifiedSymbolInformation | None:
+        """
+        Finds the container of the given symbol if there is one. If the parent attribute is present, the parent is returned
+        without further searching.
+
+        :param symbol: The symbol to find the container of.
+        :param include_body: whether to include the body of the symbol in the result.
+        :return: The container of the given symbol or None if no container is found.
+        """
+        if "parent" in symbol:
+            return symbol["parent"]
+        assert "location" in symbol, f"Symbol {symbol} has no location and no parent attribute"
+        return self.request_containing_symbol(
+            symbol["location"]["relativePath"],
+            symbol["location"]["range"]["start"]["line"],
+            symbol["location"]["range"]["start"]["character"],
+            strict=True,
+            include_body=include_body,
+        )
+
+    def request_defining_symbol(
+        self,
+        relative_file_path: str,
+        line: int,
+        column: int,
+        include_body: bool = False,
+    ) -> ls_types.UnifiedSymbolInformation | None:
+        """
+        Finds the symbol that defines the symbol at the given location.
+
+        This method first finds the definition of the symbol at the given position,
+        then retrieves the full symbol information for that definition.
+
+        :param relative_file_path: The relative path to the file.
+        :param line: The 0-indexed line number.
+        :param column: The 0-indexed column number.
+        :param include_body: whether to include the body of the symbol in the result.
+        :return: The symbol information for the definition, or None if not found.
+        """
+        if not self.server_started:
+            self.logger.log(
+                "request_defining_symbol called before Language Server started",
+                logging.ERROR,
+            )
+            raise SolidLSPException("Language Server not started")
+
+        # Get the definition location(s)
+        definitions = self.request_definition(relative_file_path, line, column)
+        if not definitions:
+            return None
+
+        # Use the first definition location
+        definition = definitions[0]
+        def_path = definition["relativePath"]
+        def_line = definition["range"]["start"]["line"]
+        def_col = definition["range"]["start"]["character"]
+
+        # Find the symbol at or containing this location
+        defining_symbol = self.request_containing_symbol(def_path, def_line, def_col, strict=False, include_body=include_body)
+
+        return defining_symbol
+
+    @property
+    def cache_path(self) -> Path:
+        """
+        The path to the cache file for the document symbols.
+        """
+        return (
+            Path(self.repository_root_path)
+            / self._solidlsp_settings.project_data_relative_path
+            / self.CACHE_FOLDER_NAME
+            / self.language_id
+            / "document_symbols_cache_v23-06-25.pkl"
+        )
+
+    def save_cache(self):
+        with self._cache_lock:
+            if not self._cache_has_changed:
+                self.logger.log("No changes to document symbols cache, skipping save", logging.DEBUG)
+                return
+
+            self.logger.log(f"Saving updated document symbols cache to {self.cache_path}", logging.INFO)
+            self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                with open(self.cache_path, "wb") as f:
+                    pickle.dump(self._document_symbols_cache, f)
+                self._cache_has_changed = False
+            except Exception as e:
+                self.logger.log(
+                    f"Failed to save document symbols cache to {self.cache_path}: {e}. "
+                    "Note: this may have resulted in a corrupted cache file.",
+                    logging.ERROR,
+                )
+
+    def load_cache(self):
+        if not self.cache_path.exists():
+            return
+
+        with self._cache_lock:
+            self.logger.log(f"Loading document symbols cache from {self.cache_path}", logging.INFO)
+            try:
+                with open(self.cache_path, "rb") as f:
+                    self._document_symbols_cache = pickle.load(f)
+                self.logger.log(f"Loaded {len(self._document_symbols_cache)} document symbols from cache.", logging.INFO)
+            except Exception as e:
+                # cache often becomes corrupt, so just skip loading it
+                self.logger.log(
+                    f"Failed to load document symbols cache from {self.cache_path}: {e}. Possible cause: the cache file is corrupted. "
+                    "Check for any errors related to saving the cache in the logs.",
+                    logging.ERROR,
+                )
+
+    def request_workspace_symbol(self, query: str) -> list[ls_types.UnifiedSymbolInformation] | None:
+        """
+        Raise a [workspace/symbol](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspace_symbol) request to the Language Server
+        to find symbols across the whole workspace. Wait for the response and return the result.
+
+        :param query: The query string to filter symbols by
+
+        :return: A list of matching symbols
+        """
+        response = self.server.send.workspace_symbol({"query": query})
+        if response is None:
+            return None
+
+        assert isinstance(response, list)
+
+        ret: list[ls_types.UnifiedSymbolInformation] = []
+        for item in response:
+            assert isinstance(item, dict)
+
+            assert LSPConstants.NAME in item
+            assert LSPConstants.KIND in item
+            assert LSPConstants.LOCATION in item
+
+            ret.append(ls_types.UnifiedSymbolInformation(**item))
+
+        return ret
+
+    def start(self) -> "SolidLanguageServer":
+        """
+        Starts the language server process and connects to it. Call shutdown when ready.
+
+        :return: self for method chaining
+        """
+        self.logger.log(
+            f"Starting language server with language {self.language_server.language} for {self.language_server.repository_root_path}",
+            logging.INFO,
+        )
+        self._server_context = self._start_server_process()
+        return self
+
+    def stop(self, shutdown_timeout: float = 2.0) -> None:
+        self._shutdown(timeout=shutdown_timeout)
+
+    @property
+    def language_server(self) -> Self:
+        return self
+
+    def is_running(self) -> bool:
+        return self.server.is_running()

projects/ui/serena-new/src/solidlsp/ls_config.py

@@ -0,0 +1,156 @@
+"""
+Configuration objects for language servers
+"""
+
+import fnmatch
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Self
+
+
+class FilenameMatcher:
+    def __init__(self, *patterns: str) -> None:
+        """
+        :param patterns: fnmatch-compatible patterns
+        """
+        self.patterns = patterns
+
+    def is_relevant_filename(self, fn: str) -> bool:
+        for pattern in self.patterns:
+            if fnmatch.fnmatch(fn, pattern):
+                return True
+        return False
+
+
+class Language(str, Enum):
+    """
+    Possible languages with Multilspy.
+    """
+
+    CSHARP = "csharp"
+    PYTHON = "python"
+    RUST = "rust"
+    JAVA = "java"
+    KOTLIN = "kotlin"
+    TYPESCRIPT = "typescript"
+    GO = "go"
+    RUBY = "ruby"
+    DART = "dart"
+    CPP = "cpp"
+    PHP = "php"
+    R = "r"
+    CLOJURE = "clojure"
+    ELIXIR = "elixir"
+    TERRAFORM = "terraform"
+    SWIFT = "swift"
+    BASH = "bash"
+    ZIG = "zig"
+    LUA = "lua"
+    NIX = "nix"
+    ERLANG = "erlang"
+    # Experimental or deprecated Language Servers
+    TYPESCRIPT_VTS = "typescript_vts"
+    """Use the typescript language server through the natively bundled vscode extension via https://github.com/yioneko/vtsls"""
+    PYTHON_JEDI = "python_jedi"
+    """Jedi language server for Python (instead of pyright, which is the default)"""
+    CSHARP_OMNISHARP = "csharp_omnisharp"
+    """OmniSharp language server for C# (instead of the default csharp-ls by microsoft).
+    Currently has problems with finding references, and generally seems less stable and performant.
+    """
+    RUBY_SOLARGRAPH = "ruby_solargraph"
+    """Solargraph language server for Ruby (legacy, experimental).
+    Use Language.RUBY (ruby-lsp) for better performance and modern LSP features.
+    """
+
+    @classmethod
+    def iter_all(cls, include_experimental: bool = False) -> Iterable[Self]:
+        for lang in cls:
+            if include_experimental or not lang.is_experimental():
+                yield lang
+
+    def is_experimental(self) -> bool:
+        """
+        Check if the language server is experimental or deprecated.
+        """
+        return self in {self.TYPESCRIPT_VTS, self.PYTHON_JEDI, self.CSHARP_OMNISHARP, self.RUBY_SOLARGRAPH}
+
+    def __str__(self) -> str:
+        return self.value
+
+    def get_source_fn_matcher(self) -> FilenameMatcher:
+        match self:
+            case self.PYTHON | self.PYTHON_JEDI:
+                return FilenameMatcher("*.py", "*.pyi")
+            case self.JAVA:
+                return FilenameMatcher("*.java")
+            case self.TYPESCRIPT | self.TYPESCRIPT_VTS:
+                # see https://github.com/oraios/serena/issues/204
+                path_patterns = []
+                for prefix in ["c", "m", ""]:
+                    for postfix in ["x", ""]:
+                        for base_pattern in ["ts", "js"]:
+                            path_patterns.append(f"*.{prefix}{base_pattern}{postfix}")
+                return FilenameMatcher(*path_patterns)
+            case self.CSHARP | self.CSHARP_OMNISHARP:
+                return FilenameMatcher("*.cs")
+            case self.RUST:
+                return FilenameMatcher("*.rs")
+            case self.GO:
+                return FilenameMatcher("*.go")
+            case self.RUBY:
+                return FilenameMatcher("*.rb", "*.erb")
+            case self.RUBY_SOLARGRAPH:
+                return FilenameMatcher("*.rb")
+            case self.CPP:
+                return FilenameMatcher("*.cpp", "*.h", "*.hpp", "*.c", "*.hxx", "*.cc", "*.cxx")
+            case self.KOTLIN:
+                return FilenameMatcher("*.kt", "*.kts")
+            case self.DART:
+                return FilenameMatcher("*.dart")
+            case self.PHP:
+                return FilenameMatcher("*.php")
+            case self.R:
+                return FilenameMatcher("*.R", "*.r", "*.Rmd", "*.Rnw")
+            case self.CLOJURE:
+                return FilenameMatcher("*.clj", "*.cljs", "*.cljc", "*.edn")  # codespell:ignore edn
+            case self.ELIXIR:
+                return FilenameMatcher("*.ex", "*.exs")
+            case self.TERRAFORM:
+                return FilenameMatcher("*.tf", "*.tfvars", "*.tfstate")
+            case self.SWIFT:
+                return FilenameMatcher("*.swift")
+            case self.BASH:
+                return FilenameMatcher("*.sh", "*.bash")
+            case self.ZIG:
+                return FilenameMatcher("*.zig", "*.zon")
+            case self.LUA:
+                return FilenameMatcher("*.lua")
+            case self.NIX:
+                return FilenameMatcher("*.nix")
+            case self.ERLANG:
+                return FilenameMatcher("*.erl", "*.hrl", "*.escript", "*.config", "*.app", "*.app.src")
+            case _:
+                raise ValueError(f"Unhandled language: {self}")
+
+
+@dataclass
+class LanguageServerConfig:
+    """
+    Configuration parameters
+    """
+
+    code_language: Language
+    trace_lsp_communication: bool = False
+    start_independent_lsp_process: bool = True
+    ignored_paths: list[str] = field(default_factory=list)
+    """Paths, dirs or glob-like patterns. The matching will follow the same logic as for .gitignore entries"""
+
+    @classmethod
+    def from_dict(cls, env: dict):
+        """
+        Create a MultilspyConfig instance from a dictionary
+        """
+        import inspect
+
+        return cls(**{k: v for k, v in env.items() if k in inspect.signature(cls).parameters})

projects/ui/serena-new/src/solidlsp/ls_exceptions.py

@@ -0,0 +1,40 @@
+"""
+This module contains the exceptions raised by the framework.
+"""
+
+
+class SolidLSPException(Exception):
+    def __init__(self, message: str, cause: Exception | None = None):
+        """
+        Initializes the exception with the given message.
+
+        :param message: the message describing the exception
+        :param cause: the original exception that caused this exception, if any.
+            For exceptions raised during request handling, this is typically
+                * an LSPError for errors returned by the LSP server
+                * LanguageServerTerminatedException for errors due to the language server having terminated.
+        """
+        self.cause = cause
+        super().__init__(message)
+
+    def is_language_server_terminated(self):
+        """
+        :return: True if the exception is caused by the language server having terminated as indicated
+            by the causing exception being an instance of LanguageServerTerminatedException.
+        """
+        from .ls_handler import LanguageServerTerminatedException
+
+        return isinstance(self.cause, LanguageServerTerminatedException)
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the exception.
+        """
+        s = super().__str__()
+        if self.cause:
+            if "\n" in s:
+                s += "\n"
+            else:
+                s += " "
+            s += f"(caused by {self.cause})"
+        return s

projects/ui/serena-new/src/solidlsp/ls_handler.py

@@ -0,0 +1,581 @@
+import asyncio
+import json
+import logging
+import os
+import platform
+import subprocess
+import threading
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from queue import Empty, Queue
+from typing import Any
+
+import psutil
+from sensai.util.string import ToStringMixin
+
+from solidlsp.ls_exceptions import SolidLSPException
+from solidlsp.ls_request import LanguageServerRequest
+from solidlsp.lsp_protocol_handler.lsp_requests import LspNotification
+from solidlsp.lsp_protocol_handler.lsp_types import ErrorCodes
+from solidlsp.lsp_protocol_handler.server import (
+    ENCODING,
+    LSPError,
+    MessageType,
+    PayloadLike,
+    ProcessLaunchInfo,
+    StringDict,
+    content_length,
+    create_message,
+    make_error_response,
+    make_notification,
+    make_request,
+    make_response,
+)
+from solidlsp.util.subprocess_util import subprocess_kwargs
+
+log = logging.getLogger(__name__)
+
+
+class LanguageServerTerminatedException(Exception):
+    """
+    Exception raised when the language server process has terminated unexpectedly.
+    """
+
+    def __init__(self, message: str, cause: Exception | None = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.cause = cause
+
+    def __str__(self) -> str:
+        return f"LanguageServerTerminatedException: {self.message}" + (f"; Cause: {self.cause}" if self.cause else "")
+
+
+class Request(ToStringMixin):
+
+    @dataclass
+    class Result:
+        payload: PayloadLike | None = None
+        error: Exception | None = None
+
+        def is_error(self) -> bool:
+            return self.error is not None
+
+    def __init__(self, request_id: int, method: str) -> None:
+        self._request_id = request_id
+        self._method = method
+        self._status = "pending"
+        self._result_queue = Queue()
+
+    def _tostring_includes(self) -> list[str]:
+        return ["_request_id", "_status", "_method"]
+
+    def on_result(self, params: PayloadLike) -> None:
+        self._status = "completed"
+        self._result_queue.put(Request.Result(payload=params))
+
+    def on_error(self, err: Exception) -> None:
+        """
+        :param err: the error that occurred while processing the request (typically an LSPError
+            for errors returned by the LS or LanguageServerTerminatedException if the error
+            is due to the language server process terminating unexpectedly).
+        """
+        self._status = "error"
+        self._result_queue.put(Request.Result(error=err))
+
+    def get_result(self, timeout: float | None = None) -> Result:
+        try:
+            return self._result_queue.get(timeout=timeout)
+        except Empty as e:
+            if timeout is not None:
+                raise TimeoutError(f"Request timed out ({timeout=})") from e
+            raise e
+
+
+class SolidLanguageServerHandler:
+    """
+    This class provides the implementation of Python client for the Language Server Protocol.
+    A class that launches the language server and communicates with it
+    using the Language Server Protocol (LSP).
+
+    It provides methods for sending requests, responses, and notifications to the server
+    and for registering handlers for requests and notifications from the server.
+
+    Uses JSON-RPC 2.0 for communication with the server over stdin/stdout.
+
+    Attributes:
+        send: A LspRequest object that can be used to send requests to the server and
+            await for the responses.
+        notify: A LspNotification object that can be used to send notifications to the server.
+        cmd: A string that represents the command to launch the language server process.
+        process: A subprocess.Popen object that represents the language server process.
+        request_id: An integer that represents the next available request id for the client.
+        _pending_requests: A dictionary that maps request ids to Request objects that
+            store the results or errors of the requests.
+        on_request_handlers: A dictionary that maps method names to callback functions
+            that handle requests from the server.
+        on_notification_handlers: A dictionary that maps method names to callback functions
+            that handle notifications from the server.
+        logger: An optional function that takes two strings (source and destination) and
+            a payload dictionary, and logs the communication between the client and the server.
+        tasks: A dictionary that maps task ids to asyncio.Task objects that represent
+            the asynchronous tasks created by the handler.
+        task_counter: An integer that represents the next available task id for the handler.
+        loop: An asyncio.AbstractEventLoop object that represents the event loop used by the handler.
+        start_independent_lsp_process: An optional boolean flag that indicates whether to start the
+        language server process in an independent process group. Default is `True`. Setting it to
+        `False` means that the language server process will be in the same process group as the
+        the current process, and any SIGINT and SIGTERM signals will be sent to both processes.
+
+    """
+
+    def __init__(
+        self,
+        process_launch_info: ProcessLaunchInfo,
+        logger: Callable[[str, str, StringDict | str], None] | None = None,
+        start_independent_lsp_process=True,
+        request_timeout: float | None = None,
+    ) -> None:
+        self.send = LanguageServerRequest(self)
+        self.notify = LspNotification(self.send_notification)
+
+        self.process_launch_info = process_launch_info
+        self.process: subprocess.Popen | None = None
+        self._is_shutting_down = False
+
+        self.request_id = 1
+        self._pending_requests: dict[Any, Request] = {}
+        self.on_request_handlers = {}
+        self.on_notification_handlers = {}
+        self.logger = logger
+        self.tasks = {}
+        self.task_counter = 0
+        self.loop = None
+        self.start_independent_lsp_process = start_independent_lsp_process
+        self._request_timeout = request_timeout
+
+        # Add thread locks for shared resources to prevent race conditions
+        self._stdin_lock = threading.Lock()
+        self._request_id_lock = threading.Lock()
+        self._response_handlers_lock = threading.Lock()
+        self._tasks_lock = threading.Lock()
+
+    def set_request_timeout(self, timeout: float | None) -> None:
+        """
+        :param timeout: the timeout, in seconds, for all requests sent to the language server.
+        """
+        self._request_timeout = timeout
+
+    def is_running(self) -> bool:
+        """
+        Checks if the language server process is currently running.
+        """
+        return self.process is not None and self.process.returncode is None
+
+    def start(self) -> None:
+        """
+        Starts the language server process and creates a task to continuously read from its stdout to handle communications
+        from the server to the client
+        """
+        child_proc_env = os.environ.copy()
+        child_proc_env.update(self.process_launch_info.env)
+
+        cmd = self.process_launch_info.cmd
+        is_windows = platform.system() == "Windows"
+        if not isinstance(cmd, str) and not is_windows:
+            # Since we are using the shell, we need to convert the command list to a single string
+            # on Linux/macOS
+            cmd = " ".join(cmd)
+        log.info("Starting language server process via command: %s", self.process_launch_info.cmd)
+        kwargs = subprocess_kwargs()
+        kwargs["start_new_session"] = self.start_independent_lsp_process
+        self.process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=child_proc_env,
+            cwd=self.process_launch_info.cwd,
+            shell=True,
+            **kwargs,
+        )
+
+        # Check if process terminated immediately
+        if self.process.returncode is not None:
+            log.error("Language server has already terminated/could not be started")
+            # Process has already terminated
+            stderr_data = self.process.stderr.read()
+            error_message = stderr_data.decode("utf-8", errors="replace")
+            raise RuntimeError(f"Process terminated immediately with code {self.process.returncode}. Error: {error_message}")
+
+        # start threads to read stdout and stderr of the process
+        threading.Thread(
+            target=self._read_ls_process_stdout,
+            name="LSP-stdout-reader",
+            daemon=True,
+        ).start()
+        threading.Thread(
+            target=self._read_ls_process_stderr,
+            name="LSP-stderr-reader",
+            daemon=True,
+        ).start()
+
+    def stop(self) -> None:
+        """
+        Sends the terminate signal to the language server process and waits for it to exit, with a timeout, killing it if necessary
+        """
+        process = self.process
+        self.process = None
+        if process:
+            self._cleanup_process(process)
+
+    def _cleanup_process(self, process):
+        """Clean up a process: close stdin, terminate/kill process, close stdout/stderr."""
+        # Close stdin first to prevent deadlocks
+        # See: https://bugs.python.org/issue35539
+        self._safely_close_pipe(process.stdin)
+
+        # Terminate/kill the process if it's still running
+        if process.returncode is None:
+            self._terminate_or_kill_process(process)
+
+        # Close stdout and stderr pipes after process has exited
+        # This is essential to prevent "I/O operation on closed pipe" errors and
+        # "Event loop is closed" errors during garbage collection
+        # See: https://bugs.python.org/issue41320 and https://github.com/python/cpython/issues/88050
+        self._safely_close_pipe(process.stdout)
+        self._safely_close_pipe(process.stderr)
+
+    def _safely_close_pipe(self, pipe):
+        """Safely close a pipe, ignoring any exceptions."""
+        if pipe:
+            try:
+                pipe.close()
+            except Exception:
+                pass
+
+    def _terminate_or_kill_process(self, process):
+        """Try to terminate the process gracefully, then forcefully if necessary."""
+        # First try to terminate the process tree gracefully
+        self._signal_process_tree(process, terminate=True)
+
+    def _signal_process_tree(self, process, terminate=True):
+        """Send signal (terminate or kill) to the process and all its children."""
+        signal_method = "terminate" if terminate else "kill"
+
+        # Try to get the parent process
+        parent = None
+        try:
+            parent = psutil.Process(process.pid)
+        except (psutil.NoSuchProcess, psutil.AccessDenied, Exception):
+            pass
+
+        # If we have the parent process and it's running, signal the entire tree
+        if parent and parent.is_running():
+            # Signal children first
+            for child in parent.children(recursive=True):
+                try:
+                    getattr(child, signal_method)()
+                except (psutil.NoSuchProcess, psutil.AccessDenied, Exception):
+                    pass
+
+            # Then signal the parent
+            try:
+                getattr(parent, signal_method)()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, Exception):
+                pass
+        else:
+            # Fall back to direct process signaling
+            try:
+                getattr(process, signal_method)()
+            except Exception:
+                pass
+
+    def shutdown(self) -> None:
+        """
+        Perform the shutdown sequence for the client, including sending the shutdown request to the server and notifying it of exit
+        """
+        self._is_shutting_down = True
+        self._log("Sending shutdown request to server")
+        self.send.shutdown()
+        self._log("Received shutdown response from server")
+        self._log("Sending exit notification to server")
+        self.notify.exit()
+        self._log("Sent exit notification to server")
+
+    def _log(self, message: str | StringDict) -> None:
+        """
+        Create a log message
+        """
+        if self.logger is not None:
+            self.logger("client", "logger", message)
+
+    @staticmethod
+    def _read_bytes_from_process(process, stream, num_bytes):
+        """Read exactly num_bytes from process stdout"""
+        data = b""
+        while len(data) < num_bytes:
+            chunk = stream.read(num_bytes - len(data))
+            if not chunk:
+                if process.poll() is not None:
+                    raise LanguageServerTerminatedException(
+                        f"Process terminated while trying to read response (read {num_bytes} of {len(data)} bytes before termination)"
+                    )
+                # Process still running but no data available yet, retry after a short delay
+                time.sleep(0.01)
+                continue
+            data += chunk
+        return data
+
+    def _read_ls_process_stdout(self) -> None:
+        """
+        Continuously read from the language server process stdout and handle the messages
+        invoking the registered response and notification handlers
+        """
+        exception: Exception | None = None
+        try:
+            while self.process and self.process.stdout:
+                if self.process.poll() is not None:  # process has terminated
+                    break
+                line = self.process.stdout.readline()
+                if not line:
+                    continue
+                try:
+                    num_bytes = content_length(line)
+                except ValueError:
+                    continue
+                if num_bytes is None:
+                    continue
+                while line and line.strip():
+                    line = self.process.stdout.readline()
+                if not line:
+                    continue
+                body = self._read_bytes_from_process(self.process, self.process.stdout, num_bytes)
+
+                self._handle_body(body)
+        except LanguageServerTerminatedException as e:
+            exception = e
+        except (BrokenPipeError, ConnectionResetError) as e:
+            exception = LanguageServerTerminatedException("Language server process terminated while reading stdout", cause=e)
+        except Exception as e:
+            exception = LanguageServerTerminatedException("Unexpected error while reading stdout from language server process", cause=e)
+        log.info("Language server stdout reader thread has terminated")
+        if not self._is_shutting_down:
+            if exception is None:
+                exception = LanguageServerTerminatedException("Language server stdout read process terminated unexpectedly")
+            log.error(str(exception))
+            self._cancel_pending_requests(exception)
+
+    def _read_ls_process_stderr(self) -> None:
+        """
+        Continuously read from the language server process stderr and log the messages
+        """
+        try:
+            while self.process and self.process.stderr:
+                if self.process.poll() is not None:
+                    # process has terminated
+                    break
+                line = self.process.stderr.readline()
+                if not line:
+                    continue
+                line = line.decode(ENCODING, errors="replace")
+                line_lower = line.lower()
+                if "error" in line_lower or "exception" in line_lower or line.startswith("E["):
+                    level = logging.ERROR
+                else:
+                    level = logging.INFO
+                log.log(level, line)
+        except Exception as e:
+            log.error("Error while reading stderr from language server process: %s", e, exc_info=e)
+        if not self._is_shutting_down:
+            log.error("Language server stderr reader thread terminated unexpectedly")
+        else:
+            log.info("Language server stderr reader thread has terminated")
+
+    def _handle_body(self, body: bytes) -> None:
+        """
+        Parse the body text received from the language server process and invoke the appropriate handler
+        """
+        try:
+            self._receive_payload(json.loads(body))
+        except OSError as ex:
+            self._log(f"malformed {ENCODING}: {ex}")
+        except UnicodeDecodeError as ex:
+            self._log(f"malformed {ENCODING}: {ex}")
+        except json.JSONDecodeError as ex:
+            self._log(f"malformed JSON: {ex}")
+
+    def _receive_payload(self, payload: StringDict) -> None:
+        """
+        Determine if the payload received from server is for a request, response, or notification and invoke the appropriate handler
+        """
+        if self.logger:
+            self.logger("server", "client", payload)
+        try:
+            if "method" in payload:
+                if "id" in payload:
+                    self._request_handler(payload)
+                else:
+                    self._notification_handler(payload)
+            elif "id" in payload:
+                self._response_handler(payload)
+            else:
+                self._log(f"Unknown payload type: {payload}")
+        except Exception as err:
+            self._log(f"Error handling server payload: {err}")
+
+    def send_notification(self, method: str, params: dict | None = None) -> None:
+        """
+        Send notification pertaining to the given method to the server with the given parameters
+        """
+        self._send_payload(make_notification(method, params))
+
+    def send_response(self, request_id: Any, params: PayloadLike) -> None:
+        """
+        Send response to the given request id to the server with the given parameters
+        """
+        self._send_payload(make_response(request_id, params))
+
+    def send_error_response(self, request_id: Any, err: LSPError) -> None:
+        """
+        Send error response to the given request id to the server with the given error
+        """
+        # Use lock to prevent race conditions on tasks and task_counter
+        self._send_payload(make_error_response(request_id, err))
+
+    def _cancel_pending_requests(self, exception: Exception) -> None:
+        """
+        Cancel all pending requests by setting their results to an error
+        """
+        with self._response_handlers_lock:
+            log.info("Cancelling %d pending language server requests", len(self._pending_requests))
+            for request in self._pending_requests.values():
+                log.info("Cancelling %s", request)
+                request.on_error(exception)
+            self._pending_requests.clear()
+
+    def send_request(self, method: str, params: dict | None = None) -> PayloadLike:
+        """
+        Send request to the server, register the request id, and wait for the response
+        """
+        with self._request_id_lock:
+            request_id = self.request_id
+            self.request_id += 1
+
+        request = Request(request_id=request_id, method=method)
+        log.debug("Starting: %s", request)
+
+        with self._response_handlers_lock:
+            self._pending_requests[request_id] = request
+
+        self._send_payload(make_request(method, request_id, params))
+
+        self._log(f"Waiting for response to request {method} with params:\n{params}")
+        result = request.get_result(timeout=self._request_timeout)
+        log.debug("Completed: %s", request)
+
+        self._log("Processing result")
+        if result.is_error():
+            raise SolidLSPException(f"Error processing request {method} with params:\n{params}", cause=result.error) from result.error
+
+        self._log(f"Returning non-error result, which is:\n{result.payload}")
+        return result.payload
+
+    def _send_payload(self, payload: StringDict) -> None:
+        """
+        Send the payload to the server by writing to its stdin asynchronously.
+        """
+        if not self.process or not self.process.stdin:
+            return
+        self._log(payload)
+        msg = create_message(payload)
+
+        # Use lock to prevent concurrent writes to stdin that cause buffer corruption
+        with self._stdin_lock:
+            try:
+                self.process.stdin.writelines(msg)
+                self.process.stdin.flush()
+            except (BrokenPipeError, ConnectionResetError, OSError) as e:
+                # Log the error but don't raise to prevent cascading failures
+                if self.logger:
+                    self.logger("client", "logger", f"Failed to write to stdin: {e}")
+                return
+
+    def on_request(self, method: str, cb) -> None:
+        """
+        Register the callback function to handle requests from the server to the client for the given method
+        """
+        self.on_request_handlers[method] = cb
+
+    def on_notification(self, method: str, cb) -> None:
+        """
+        Register the callback function to handle notifications from the server to the client for the given method
+        """
+        self.on_notification_handlers[method] = cb
+
+    def _response_handler(self, response: StringDict) -> None:
+        """
+        Handle the response received from the server for a request, using the id to determine the request
+        """
+        with self._response_handlers_lock:
+            request = self._pending_requests.pop(response["id"])
+
+        if "result" in response and "error" not in response:
+            request.on_result(response["result"])
+        elif "result" not in response and "error" in response:
+            request.on_error(LSPError.from_lsp(response["error"]))
+        else:
+            request.on_error(LSPError(ErrorCodes.InvalidRequest, ""))
+
+    def _request_handler(self, response: StringDict) -> None:
+        """
+        Handle the request received from the server: call the appropriate callback function and return the result
+        """
+        method = response.get("method", "")
+        params = response.get("params")
+        request_id = response.get("id")
+        handler = self.on_request_handlers.get(method)
+        if not handler:
+            self.send_error_response(
+                request_id,
+                LSPError(
+                    ErrorCodes.MethodNotFound,
+                    f"method '{method}' not handled on client.",
+                ),
+            )
+            return
+        try:
+            self.send_response(request_id, handler(params))
+        except LSPError as ex:
+            self.send_error_response(request_id, ex)
+        except Exception as ex:
+            self.send_error_response(request_id, LSPError(ErrorCodes.InternalError, str(ex)))
+
+    def _notification_handler(self, response: StringDict) -> None:
+        """
+        Handle the notification received from the server: call the appropriate callback function
+        """
+        method = response.get("method", "")
+        params = response.get("params")
+        handler = self.on_notification_handlers.get(method)
+        if not handler:
+            self._log(f"unhandled {method}")
+            return
+        try:
+            handler(params)
+        except asyncio.CancelledError:
+            return
+        except Exception as ex:
+            if (not self._is_shutting_down) and self.logger:
+                self.logger(
+                    "client",
+                    "logger",
+                    str(
+                        {
+                            "type": MessageType.error,
+                            "message": str(ex),
+                            "method": method,
+                            "params": params,
+                        }
+                    ),
+                )

projects/ui/serena-new/src/solidlsp/ls_logger.py

@@ -0,0 +1,66 @@
+"""
+Multilspy logger module.
+"""
+
+import inspect
+import logging
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class LogLine(BaseModel):
+    """
+    Represents a line in the Multilspy log
+    """
+
+    time: str
+    level: str
+    caller_file: str
+    caller_name: str
+    caller_line: int
+    message: str
+
+
+class LanguageServerLogger:
+    """
+    Logger class
+    """
+
+    def __init__(self, json_format: bool = False, log_level: int = logging.INFO) -> None:
+        self.logger = logging.getLogger("solidlsp")
+        self.logger.setLevel(log_level)
+        self.json_format = json_format
+
+    def log(self, debug_message: str, level: int, sanitized_error_message: str = "", stacklevel: int = 2) -> None:
+        """
+        Log the debug and sanitized messages using the logger
+        """
+        debug_message = debug_message.replace("'", '"').replace("\n", " ")
+        sanitized_error_message = sanitized_error_message.replace("'", '"').replace("\n", " ")
+
+        # Collect details about the callee
+        curframe = inspect.currentframe()
+        calframe = inspect.getouterframes(curframe, 2)
+        caller_file = calframe[1][1].split("/")[-1]
+        caller_line = calframe[1][2]
+        caller_name = calframe[1][3]
+
+        if self.json_format:
+            # Construct the debug log line
+            debug_log_line = LogLine(
+                time=str(datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
+                level=logging.getLevelName(level),
+                caller_file=caller_file,
+                caller_name=caller_name,
+                caller_line=caller_line,
+                message=debug_message,
+            )
+
+            self.logger.log(
+                level=level,
+                msg=debug_log_line.json(),
+                stacklevel=stacklevel,
+            )
+        else:
+            self.logger.log(level, debug_message, stacklevel=stacklevel)

projects/ui/serena-new/src/solidlsp/ls_request.py

@@ -0,0 +1,383 @@
+from typing import TYPE_CHECKING, Any, Union
+
+from solidlsp.lsp_protocol_handler import lsp_types
+
+if TYPE_CHECKING:
+    from .ls_handler import SolidLanguageServerHandler
+
+
+class LanguageServerRequest:
+    def __init__(self, handler: "SolidLanguageServerHandler"):
+        self.handler = handler
+
+    def _send_request(self, method: str, params: Any | None = None) -> Any:
+        return self.handler.send_request(method, params)
+
+    def implementation(self, params: lsp_types.ImplementationParams) -> Union["lsp_types.Definition", list["lsp_types.LocationLink"], None]:
+        """A request to resolve the implementation locations of a symbol at a given text
+        document position. The request's parameter is of type [TextDocumentPositionParams]
+        (#TextDocumentPositionParams) the response is of type {@link Definition} or a
+        Thenable that resolves to such.
+        """
+        return self._send_request("textDocument/implementation", params)
+
+    def type_definition(
+        self, params: lsp_types.TypeDefinitionParams
+    ) -> Union["lsp_types.Definition", list["lsp_types.LocationLink"], None]:
+        """A request to resolve the type definition locations of a symbol at a given text
+        document position. The request's parameter is of type [TextDocumentPositionParams]
+        (#TextDocumentPositionParams) the response is of type {@link Definition} or a
+        Thenable that resolves to such.
+        """
+        return self._send_request("textDocument/typeDefinition", params)
+
+    def document_color(self, params: lsp_types.DocumentColorParams) -> list["lsp_types.ColorInformation"]:
+        """A request to list all color symbols found in a given text document. The request's
+        parameter is of type {@link DocumentColorParams} the
+        response is of type {@link ColorInformation ColorInformation[]} or a Thenable
+        that resolves to such.
+        """
+        return self._send_request("textDocument/documentColor", params)
+
+    def color_presentation(self, params: lsp_types.ColorPresentationParams) -> list["lsp_types.ColorPresentation"]:
+        """A request to list all presentation for a color. The request's
+        parameter is of type {@link ColorPresentationParams} the
+        response is of type {@link ColorInformation ColorInformation[]} or a Thenable
+        that resolves to such.
+        """
+        return self._send_request("textDocument/colorPresentation", params)
+
+    def folding_range(self, params: lsp_types.FoldingRangeParams) -> list["lsp_types.FoldingRange"] | None:
+        """A request to provide folding ranges in a document. The request's
+        parameter is of type {@link FoldingRangeParams}, the
+        response is of type {@link FoldingRangeList} or a Thenable
+        that resolves to such.
+        """
+        return self._send_request("textDocument/foldingRange", params)
+
+    def declaration(self, params: lsp_types.DeclarationParams) -> Union["lsp_types.Declaration", list["lsp_types.LocationLink"], None]:
+        """A request to resolve the type definition locations of a symbol at a given text
+        document position. The request's parameter is of type [TextDocumentPositionParams]
+        (#TextDocumentPositionParams) the response is of type {@link Declaration}
+        or a typed array of {@link DeclarationLink} or a Thenable that resolves
+        to such.
+        """
+        return self._send_request("textDocument/declaration", params)
+
+    def selection_range(self, params: lsp_types.SelectionRangeParams) -> list["lsp_types.SelectionRange"] | None:
+        """A request to provide selection ranges in a document. The request's
+        parameter is of type {@link SelectionRangeParams}, the
+        response is of type {@link SelectionRange SelectionRange[]} or a Thenable
+        that resolves to such.
+        """
+        return self._send_request("textDocument/selectionRange", params)
+
+    def prepare_call_hierarchy(self, params: lsp_types.CallHierarchyPrepareParams) -> list["lsp_types.CallHierarchyItem"] | None:
+        """A request to result a `CallHierarchyItem` in a document at a given position.
+        Can be used as an input to an incoming or outgoing call hierarchy.
+
+        @since 3.16.0
+        """
+        return self._send_request("textDocument/prepareCallHierarchy", params)
+
+    def incoming_calls(self, params: lsp_types.CallHierarchyIncomingCallsParams) -> list["lsp_types.CallHierarchyIncomingCall"] | None:
+        """A request to resolve the incoming calls for a given `CallHierarchyItem`.
+
+        @since 3.16.0
+        """
+        return self._send_request("callHierarchy/incomingCalls", params)
+
+    def outgoing_calls(self, params: lsp_types.CallHierarchyOutgoingCallsParams) -> list["lsp_types.CallHierarchyOutgoingCall"] | None:
+        """A request to resolve the outgoing calls for a given `CallHierarchyItem`.
+
+        @since 3.16.0
+        """
+        return self._send_request("callHierarchy/outgoingCalls", params)
+
+    def semantic_tokens_full(self, params: lsp_types.SemanticTokensParams) -> Union["lsp_types.SemanticTokens", None]:
+        """@since 3.16.0"""
+        return self._send_request("textDocument/semanticTokens/full", params)
+
+    def semantic_tokens_delta(
+        self, params: lsp_types.SemanticTokensDeltaParams
+    ) -> Union["lsp_types.SemanticTokens", "lsp_types.SemanticTokensDelta", None]:
+        """@since 3.16.0"""
+        return self._send_request("textDocument/semanticTokens/full/delta", params)
+
+    def semantic_tokens_range(self, params: lsp_types.SemanticTokensRangeParams) -> Union["lsp_types.SemanticTokens", None]:
+        """@since 3.16.0"""
+        return self._send_request("textDocument/semanticTokens/range", params)
+
+    def linked_editing_range(self, params: lsp_types.LinkedEditingRangeParams) -> Union["lsp_types.LinkedEditingRanges", None]:
+        """A request to provide ranges that can be edited together.
+
+        @since 3.16.0
+        """
+        return self._send_request("textDocument/linkedEditingRange", params)
+
+    def will_create_files(self, params: lsp_types.CreateFilesParams) -> Union["lsp_types.WorkspaceEdit", None]:
+        """The will create files request is sent from the client to the server before files are actually
+        created as long as the creation is triggered from within the client.
+
+        @since 3.16.0
+        """
+        return self._send_request("workspace/willCreateFiles", params)
+
+    def will_rename_files(self, params: lsp_types.RenameFilesParams) -> Union["lsp_types.WorkspaceEdit", None]:
+        """The will rename files request is sent from the client to the server before files are actually
+        renamed as long as the rename is triggered from within the client.
+
+        @since 3.16.0
+        """
+        return self._send_request("workspace/willRenameFiles", params)
+
+    def will_delete_files(self, params: lsp_types.DeleteFilesParams) -> Union["lsp_types.WorkspaceEdit", None]:
+        """The did delete files notification is sent from the client to the server when
+        files were deleted from within the client.
+
+        @since 3.16.0
+        """
+        return self._send_request("workspace/willDeleteFiles", params)
+
+    def moniker(self, params: lsp_types.MonikerParams) -> list["lsp_types.Moniker"] | None:
+        """A request to get the moniker of a symbol at a given text document position.
+        The request parameter is of type {@link TextDocumentPositionParams}.
+        The response is of type {@link Moniker Moniker[]} or `null`.
+        """
+        return self._send_request("textDocument/moniker", params)
+
+    def prepare_type_hierarchy(self, params: lsp_types.TypeHierarchyPrepareParams) -> list["lsp_types.TypeHierarchyItem"] | None:
+        """A request to result a `TypeHierarchyItem` in a document at a given position.
+        Can be used as an input to a subtypes or supertypes type hierarchy.
+
+        @since 3.17.0
+        """
+        return self._send_request("textDocument/prepareTypeHierarchy", params)
+
+    def type_hierarchy_supertypes(self, params: lsp_types.TypeHierarchySupertypesParams) -> list["lsp_types.TypeHierarchyItem"] | None:
+        """A request to resolve the supertypes for a given `TypeHierarchyItem`.
+
+        @since 3.17.0
+        """
+        return self._send_request("typeHierarchy/supertypes", params)
+
+    def type_hierarchy_subtypes(self, params: lsp_types.TypeHierarchySubtypesParams) -> list["lsp_types.TypeHierarchyItem"] | None:
+        """A request to resolve the subtypes for a given `TypeHierarchyItem`.
+
+        @since 3.17.0
+        """
+        return self._send_request("typeHierarchy/subtypes", params)
+
+    def inline_value(self, params: lsp_types.InlineValueParams) -> list["lsp_types.InlineValue"] | None:
+        """A request to provide inline values in a document. The request's parameter is of
+        type {@link InlineValueParams}, the response is of type
+        {@link InlineValue InlineValue[]} or a Thenable that resolves to such.
+
+        @since 3.17.0
+        """
+        return self._send_request("textDocument/inlineValue", params)
+
+    def inlay_hint(self, params: lsp_types.InlayHintParams) -> list["lsp_types.InlayHint"] | None:
+        """A request to provide inlay hints in a document. The request's parameter is of
+        type {@link InlayHintsParams}, the response is of type
+        {@link InlayHint InlayHint[]} or a Thenable that resolves to such.
+
+        @since 3.17.0
+        """
+        return self._send_request("textDocument/inlayHint", params)
+
+    def resolve_inlay_hint(self, params: lsp_types.InlayHint) -> "lsp_types.InlayHint":
+        """A request to resolve additional properties for an inlay hint.
+        The request's parameter is of type {@link InlayHint}, the response is
+        of type {@link InlayHint} or a Thenable that resolves to such.
+
+        @since 3.17.0
+        """
+        return self._send_request("inlayHint/resolve", params)
+
+    def text_document_diagnostic(self, params: lsp_types.DocumentDiagnosticParams) -> "lsp_types.DocumentDiagnosticReport":
+        """The document diagnostic request definition.
+
+        @since 3.17.0
+        """
+        return self._send_request("textDocument/diagnostic", params)
+
+    def workspace_diagnostic(self, params: lsp_types.WorkspaceDiagnosticParams) -> "lsp_types.WorkspaceDiagnosticReport":
+        """The workspace diagnostic request definition.
+
+        @since 3.17.0
+        """
+        return self._send_request("workspace/diagnostic", params)
+
+    def initialize(self, params: lsp_types.InitializeParams) -> "lsp_types.InitializeResult":
+        """The initialize request is sent from the client to the server.
+        It is sent once as the request after starting up the server.
+        The requests parameter is of type {@link InitializeParams}
+        the response if of type {@link InitializeResult} of a Thenable that
+        resolves to such.
+        """
+        return self._send_request("initialize", params)
+
+    def shutdown(self) -> None:
+        """A shutdown request is sent from the client to the server.
+        It is sent once when the client decides to shutdown the
+        server. The only notification that is sent after a shutdown request
+        is the exit event.
+        """
+        return self._send_request("shutdown")
+
+    def will_save_wait_until(self, params: lsp_types.WillSaveTextDocumentParams) -> list["lsp_types.TextEdit"] | None:
+        """A document will save request is sent from the client to the server before
+        the document is actually saved. The request can return an array of TextEdits
+        which will be applied to the text document before it is saved. Please note that
+        clients might drop results if computing the text edits took too long or if a
+        server constantly fails on this request. This is done to keep the save fast and
+        reliable.
+        """
+        return self._send_request("textDocument/willSaveWaitUntil", params)
+
+    def completion(self, params: lsp_types.CompletionParams) -> Union[list["lsp_types.CompletionItem"], "lsp_types.CompletionList", None]:
+        """Request to request completion at a given text document position. The request's
+        parameter is of type {@link TextDocumentPosition} the response
+        is of type {@link CompletionItem CompletionItem[]} or {@link CompletionList}
+        or a Thenable that resolves to such.
+
+        The request can delay the computation of the {@link CompletionItem.detail `detail`}
+        and {@link CompletionItem.documentation `documentation`} properties to the `completionItem/resolve`
+        request. However, properties that are needed for the initial sorting and filtering, like `sortText`,
+        `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.
+        """
+        return self._send_request("textDocument/completion", params)
+
+    def resolve_completion_item(self, params: lsp_types.CompletionItem) -> "lsp_types.CompletionItem":
+        """Request to resolve additional information for a given completion item.The request's
+        parameter is of type {@link CompletionItem} the response
+        is of type {@link CompletionItem} or a Thenable that resolves to such.
+        """
+        return self._send_request("completionItem/resolve", params)
+
+    def hover(self, params: lsp_types.HoverParams) -> Union["lsp_types.Hover", None]:
+        """Request to request hover information at a given text document position. The request's
+        parameter is of type {@link TextDocumentPosition} the response is of
+        type {@link Hover} or a Thenable that resolves to such.
+        """
+        return self._send_request("textDocument/hover", params)
+
+    def signature_help(self, params: lsp_types.SignatureHelpParams) -> Union["lsp_types.SignatureHelp", None]:
+        return self._send_request("textDocument/signatureHelp", params)
+
+    def definition(self, params: lsp_types.DefinitionParams) -> Union["lsp_types.Definition", list["lsp_types.LocationLink"], None]:
+        """A request to resolve the definition location of a symbol at a given text
+        document position. The request's parameter is of type [TextDocumentPosition]
+        (#TextDocumentPosition) the response is of either type {@link Definition}
+        or a typed array of {@link DefinitionLink} or a Thenable that resolves
+        to such.
+        """
+        return self._send_request("textDocument/definition", params)
+
+    def references(self, params: lsp_types.ReferenceParams) -> list["lsp_types.Location"] | None:
+        """A request to resolve project-wide references for the symbol denoted
+        by the given text document position. The request's parameter is of
+        type {@link ReferenceParams} the response is of type
+        {@link Location Location[]} or a Thenable that resolves to such.
+        """
+        return self._send_request("textDocument/references", params)
+
+    def document_highlight(self, params: lsp_types.DocumentHighlightParams) -> list["lsp_types.DocumentHighlight"] | None:
+        """Request to resolve a {@link DocumentHighlight} for a given
+        text document position. The request's parameter is of type [TextDocumentPosition]
+        (#TextDocumentPosition) the request response is of type [DocumentHighlight[]]
+        (#DocumentHighlight) or a Thenable that resolves to such.
+        """
+        return self._send_request("textDocument/documentHighlight", params)
+
+    def document_symbol(
+        self, params: lsp_types.DocumentSymbolParams
+    ) -> list["lsp_types.SymbolInformation"] | list["lsp_types.DocumentSymbol"] | None:
+        """A request to list all symbols found in a given text document. The request's
+        parameter is of type {@link TextDocumentIdentifier} the
+        response is of type {@link SymbolInformation SymbolInformation[]} or a Thenable
+        that resolves to such.
+        """
+        return self._send_request("textDocument/documentSymbol", params)
+
+    def code_action(self, params: lsp_types.CodeActionParams) -> list[Union["lsp_types.Command", "lsp_types.CodeAction"]] | None:
+        """A request to provide commands for the given text document and range."""
+        return self._send_request("textDocument/codeAction", params)
+
+    def resolve_code_action(self, params: lsp_types.CodeAction) -> "lsp_types.CodeAction":
+        """Request to resolve additional information for a given code action.The request's
+        parameter is of type {@link CodeAction} the response
+        is of type {@link CodeAction} or a Thenable that resolves to such.
+        """
+        return self._send_request("codeAction/resolve", params)
+
+    def workspace_symbol(
+        self, params: lsp_types.WorkspaceSymbolParams
+    ) -> list["lsp_types.SymbolInformation"] | list["lsp_types.WorkspaceSymbol"] | None:
+        """A request to list project-wide symbols matching the query string given
+        by the {@link WorkspaceSymbolParams}. The response is
+        of type {@link SymbolInformation SymbolInformation[]} or a Thenable that
+        resolves to such.
+
+        @since 3.17.0 - support for WorkspaceSymbol in the returned data. Clients
+         need to advertise support for WorkspaceSymbols via the client capability
+         `workspace.symbol.resolveSupport`.
+        """
+        return self._send_request("workspace/symbol", params)
+
+    def resolve_workspace_symbol(self, params: lsp_types.WorkspaceSymbol) -> "lsp_types.WorkspaceSymbol":
+        """A request to resolve the range inside the workspace
+        symbol's location.
+
+        @since 3.17.0
+        """
+        return self._send_request("workspaceSymbol/resolve", params)
+
+    def code_lens(self, params: lsp_types.CodeLensParams) -> list["lsp_types.CodeLens"] | None:
+        """A request to provide code lens for the given text document."""
+        return self._send_request("textDocument/codeLens", params)
+
+    def resolve_code_lens(self, params: lsp_types.CodeLens) -> "lsp_types.CodeLens":
+        """A request to resolve a command for a given code lens."""
+        return self._send_request("codeLens/resolve", params)
+
+    def document_link(self, params: lsp_types.DocumentLinkParams) -> list["lsp_types.DocumentLink"] | None:
+        """A request to provide document links"""
+        return self._send_request("textDocument/documentLink", params)
+
+    def resolve_document_link(self, params: lsp_types.DocumentLink) -> "lsp_types.DocumentLink":
+        """Request to resolve additional information for a given document link. The request's
+        parameter is of type {@link DocumentLink} the response
+        is of type {@link DocumentLink} or a Thenable that resolves to such.
+        """
+        return self._send_request("documentLink/resolve", params)
+
+    def formatting(self, params: lsp_types.DocumentFormattingParams) -> list["lsp_types.TextEdit"] | None:
+        """A request to to format a whole document."""
+        return self._send_request("textDocument/formatting", params)
+
+    def range_formatting(self, params: lsp_types.DocumentRangeFormattingParams) -> list["lsp_types.TextEdit"] | None:
+        """A request to to format a range in a document."""
+        return self._send_request("textDocument/rangeFormatting", params)
+
+    def on_type_formatting(self, params: lsp_types.DocumentOnTypeFormattingParams) -> list["lsp_types.TextEdit"] | None:
+        """A request to format a document on type."""
+        return self._send_request("textDocument/onTypeFormatting", params)
+
+    def rename(self, params: lsp_types.RenameParams) -> Union["lsp_types.WorkspaceEdit", None]:
+        """A request to rename a symbol."""
+        return self._send_request("textDocument/rename", params)
+
+    def prepare_rename(self, params: lsp_types.PrepareRenameParams) -> Union["lsp_types.PrepareRenameResult", None]:
+        """A request to test and perform the setup necessary for a rename.
+
+        @since 3.16 - support for default behavior
+        """
+        return self._send_request("textDocument/prepareRename", params)
+
+    def execute_command(self, params: lsp_types.ExecuteCommandParams) -> Union["lsp_types.LSPAny", None]:
+        """A request send from the client to the server to execute a command. The request might return
+        a workspace edit which the client will apply to the workspace.
+        """
+        return self._send_request("workspace/executeCommand", params)

projects/ui/serena-new/src/solidlsp/ls_types.py

@@ -0,0 +1,343 @@
+"""
+Defines wrapper objects around the types returned by LSP to ensure decoupling between LSP versions and multilspy
+"""
+
+from __future__ import annotations
+
+from enum import Enum, IntEnum
+from typing import NotRequired, Union
+
+from typing_extensions import TypedDict
+
+URI = str
+DocumentUri = str
+Uint = int
+RegExp = str
+
+
+class Position(TypedDict):
+    r"""Position in a text document expressed as zero-based line and character
+    offset. Prior to 3.17 the offsets were always based on a UTF-16 string
+    representation. So a string of the form `a𐐀b` the character offset of the
+    character `a` is 0, the character offset of `𐐀` is 1 and the character
+    offset of b is 3 since `𐐀` is represented using two code units in UTF-16.
+    Since 3.17 clients and servers can agree on a different string encoding
+    representation (e.g. UTF-8). The client announces it's supported encoding
+    via the client capability [`general.positionEncodings`](#clientCapabilities).
+    The value is an array of position encodings the client supports, with
+    decreasing preference (e.g. the encoding at index `0` is the most preferred
+    one). To stay backwards compatible the only mandatory encoding is UTF-16
+    represented via the string `utf-16`. The server can pick one of the
+    encodings offered by the client and signals that encoding back to the
+    client via the initialize result's property
+    [`capabilities.positionEncoding`](#serverCapabilities). If the string value
+    `utf-16` is missing from the client's capability `general.positionEncodings`
+    servers can safely assume that the client supports UTF-16. If the server
+    omits the position encoding in its initialize result the encoding defaults
+    to the string value `utf-16`. Implementation considerations: since the
+    conversion from one encoding into another requires the content of the
+    file / line the conversion is best done where the file is read which is
+    usually on the server side.
+
+    Positions are line end character agnostic. So you can not specify a position
+    that denotes `\r|\n` or `\n|` where `|` represents the character offset.
+
+    @since 3.17.0 - support for negotiated position encoding.
+    """
+
+    line: Uint
+    """ Line position in a document (zero-based).
+
+    If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
+    If a line number is negative, it defaults to 0. """
+    character: Uint
+    """ Character offset on a line in a document (zero-based).
+
+    The meaning of this offset is determined by the negotiated
+    `PositionEncodingKind`.
+
+    If the character value is greater than the line length it defaults back to the
+    line length. """
+
+
+class Range(TypedDict):
+    """A range in a text document expressed as (zero-based) start and end positions.
+
+    If you want to specify a range that contains a line including the line ending
+    character(s) then use an end position denoting the start of the next line.
+    For example:
+    ```ts
+    {
+        start: { line: 5, character: 23 }
+        end : { line 6, character : 0 }
+    }
+    ```
+    """
+
+    start: Position
+    """ The range's start position. """
+    end: Position
+    """ The range's end position. """
+
+
+class Location(TypedDict):
+    """Represents a location inside a resource, such as a line
+    inside a text file.
+    """
+
+    uri: DocumentUri
+    range: Range
+    absolutePath: str
+    relativePath: str | None
+
+
+class CompletionItemKind(IntEnum):
+    """The kind of a completion entry."""
+
+    Text = 1
+    Method = 2
+    Function = 3
+    Constructor = 4
+    Field = 5
+    Variable = 6
+    Class = 7
+    Interface = 8
+    Module = 9
+    Property = 10
+    Unit = 11
+    Value = 12
+    Enum = 13
+    Keyword = 14
+    Snippet = 15
+    Color = 16
+    File = 17
+    Reference = 18
+    Folder = 19
+    EnumMember = 20
+    Constant = 21
+    Struct = 22
+    Event = 23
+    Operator = 24
+    TypeParameter = 25
+
+
+class CompletionItem(TypedDict):
+    """A completion item represents a text snippet that is
+    proposed to complete text that is being typed.
+    """
+
+    completionText: str
+    """ The completionText of this completion item.
+
+    The completionText property is also by default the text that
+    is inserted when selecting this completion."""
+
+    kind: CompletionItemKind
+    """ The kind of this completion item. Based of the kind
+    an icon is chosen by the editor. """
+
+    detail: NotRequired[str]
+    """ A human-readable string with additional information
+    about this item, like type or symbol information. """
+
+
+class SymbolKind(IntEnum):
+    """A symbol kind."""
+
+    File = 1
+    Module = 2
+    Namespace = 3
+    Package = 4
+    Class = 5
+    Method = 6
+    Property = 7
+    Field = 8
+    Constructor = 9
+    Enum = 10
+    Interface = 11
+    Function = 12
+    Variable = 13
+    Constant = 14
+    String = 15
+    Number = 16
+    Boolean = 17
+    Array = 18
+    Object = 19
+    Key = 20
+    Null = 21
+    EnumMember = 22
+    Struct = 23
+    Event = 24
+    Operator = 25
+    TypeParameter = 26
+
+
+class SymbolTag(IntEnum):
+    """Symbol tags are extra annotations that tweak the rendering of a symbol.
+
+    @since 3.16
+    """
+
+    Deprecated = 1
+    """ Render a symbol as obsolete, usually using a strike-out. """
+
+
+class UnifiedSymbolInformation(TypedDict):
+    """Represents information about programming constructs like variables, classes,
+    interfaces etc.
+    """
+
+    deprecated: NotRequired[bool]
+    """ Indicates if this symbol is deprecated.
+
+    @deprecated Use tags instead """
+    location: NotRequired[Location]
+    """ The location of this symbol. The location's range is used by a tool
+    to reveal the location in the editor. If the symbol is selected in the
+    tool the range's start information is used to position the cursor. So
+    the range usually spans more than the actual symbol's name and does
+    normally include things like visibility modifiers.
+
+    The range doesn't have to denote a node range in the sense of an abstract
+    syntax tree. It can therefore not be used to re-construct a hierarchy of
+    the symbols. """
+    name: str
+    """ The name of this symbol. """
+    kind: SymbolKind
+    """ The kind of this symbol. """
+    tags: NotRequired[list[SymbolTag]]
+    """ Tags for this symbol.
+
+    @since 3.16.0 """
+    containerName: NotRequired[str]
+    """ The name of the symbol containing this symbol. This information is for
+    user interface purposes (e.g. to render a qualifier in the user interface
+    if necessary). It can't be used to re-infer a hierarchy for the document
+    symbols. 
+    
+    Note: within Serena, the parent attribute was added and should be used instead. 
+    Most LS don't provide containerName.
+    """
+
+    detail: NotRequired[str]
+    """ More detail for this symbol, e.g the signature of a function. """
+
+    range: NotRequired[Range]
+    """ The range enclosing this symbol not including leading/trailing whitespace but everything else
+    like comments. This information is typically used to determine if the clients cursor is
+    inside the symbol to reveal in the symbol in the UI. """
+    selectionRange: NotRequired[Range]
+    """ The range that should be selected and revealed when this symbol is being picked, e.g the name of a function.
+    Must be contained by the `range`. """
+
+    body: NotRequired[str]
+    """ The body of the symbol. """
+
+    children: list[UnifiedSymbolInformation]
+    """ The children of the symbol. 
+    Added to be compatible with `lsp_types.DocumentSymbol`, 
+    since it is sometimes useful to have the children of the symbol as a user-facing feature."""
+
+    parent: NotRequired[UnifiedSymbolInformation | None]
+    """The parent of the symbol, if there is any. Added with Serena, not part of the LSP.
+    All symbols except the root packages will have a parent.
+    """
+
+
+class MarkupKind(Enum):
+    """Describes the content type that a client supports in various
+    result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
+
+    Please note that `MarkupKinds` must not start with a `$`. This kinds
+    are reserved for internal usage.
+    """
+
+    PlainText = "plaintext"
+    """ Plain text is supported as a content format """
+    Markdown = "markdown"
+    """ Markdown is supported as a content format """
+
+
+class __MarkedString_Type_1(TypedDict):
+    language: str
+    value: str
+
+
+MarkedString = Union[str, "__MarkedString_Type_1"]
+""" MarkedString can be used to render human readable text. It is either a markdown string
+or a code-block that provides a language and a code snippet. The language identifier
+is semantically equal to the optional language identifier in fenced code blocks in GitHub
+issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
+
+The pair of a language and a value is an equivalent to markdown:
+```${language}
+${value}
+```
+
+Note that markdown strings will be sanitized - that means html will be escaped.
+@deprecated use MarkupContent instead. """
+
+
+class MarkupContent(TypedDict):
+    r"""A `MarkupContent` literal represents a string value which content is interpreted base on its
+    kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds.
+
+    If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues.
+    See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
+
+    Here is an example how such a string can be constructed using JavaScript / TypeScript:
+    ```ts
+    let markdown: MarkdownContent = {
+     kind: MarkupKind.Markdown,
+     value: [
+       '# Header',
+       'Some text',
+       '```typescript',
+       'someCode();',
+       '```'
+     ].join('\n')
+    };
+    ```
+
+    *Please Note* that clients might sanitize the return markdown. A client could decide to
+    remove HTML from the markdown to avoid script execution.
+    """
+
+    kind: MarkupKind
+    """ The type of the Markup """
+    value: str
+    """ The content itself """
+
+
+class Hover(TypedDict):
+    """The result of a hover request."""
+
+    contents: MarkupContent | MarkedString | list[MarkedString]
+    """ The hover's content """
+    range: NotRequired[Range]
+    """ An optional range inside the text document that is used to
+    visualize the hover, e.g. by changing the background color. """
+
+
+class DiagnosticsSeverity(IntEnum):
+    ERROR = 1
+    WARNING = 2
+    INFORMATION = 3
+    HINT = 4
+
+
+class Diagnostic(TypedDict):
+    """Diagnostic information for a text document."""
+
+    uri: DocumentUri
+    """ The URI of the text document to which the diagnostics apply. """
+    range: Range
+    """ The range of the text document to which the diagnostics apply. """
+    severity: NotRequired[DiagnosticsSeverity]
+    """ The severity of the diagnostic. """
+    message: str
+    """ The diagnostic message. """
+    code: str
+    """ The code of the diagnostic. """
+    source: NotRequired[str]
+    """ The source of the diagnostic, e.g. the name of the tool that produced it. """

projects/ui/serena-new/src/solidlsp/ls_utils.py

@@ -0,0 +1,406 @@
+"""
+This file contains various utility functions like I/O operations, handling paths, etc.
+"""
+
+import gzip
+import logging
+import os
+import platform
+import shutil
+import subprocess
+import uuid
+import zipfile
+from enum import Enum
+from pathlib import Path, PurePath
+
+import requests
+
+from solidlsp.ls_exceptions import SolidLSPException
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.ls_types import UnifiedSymbolInformation
+
+
+class InvalidTextLocationError(Exception):
+    pass
+
+
+class TextUtils:
+    """
+    Utilities for text operations.
+    """
+
+    @staticmethod
+    def get_line_col_from_index(text: str, index: int) -> tuple[int, int]:
+        """
+        Returns the zero-indexed line and column number of the given index in the given text
+        """
+        l = 0
+        c = 0
+        idx = 0
+        while idx < index:
+            if text[idx] == "\n":
+                l += 1
+                c = 0
+            else:
+                c += 1
+            idx += 1
+
+        return l, c
+
+    @staticmethod
+    def get_index_from_line_col(text: str, line: int, col: int) -> int:
+        """
+        Returns the index of the given zero-indexed line and column number in the given text
+        """
+        idx = 0
+        while line > 0:
+            if idx >= len(text):
+                raise InvalidTextLocationError
+            if text[idx] == "\n":
+                line -= 1
+            idx += 1
+        idx += col
+        return idx
+
+    @staticmethod
+    def _get_updated_position_from_line_and_column_and_edit(l: int, c: int, text_to_be_inserted: str) -> tuple[int, int]:
+        """
+        Utility function to get the position of the cursor after inserting text at a given line and column.
+        """
+        num_newlines_in_gen_text = text_to_be_inserted.count("\n")
+        if num_newlines_in_gen_text > 0:
+            l += num_newlines_in_gen_text
+            c = len(text_to_be_inserted.split("\n")[-1])
+        else:
+            c += len(text_to_be_inserted)
+        return (l, c)
+
+    @staticmethod
+    def delete_text_between_positions(text: str, start_line: int, start_col: int, end_line: int, end_col: int) -> tuple[str, str]:
+        """
+        Deletes the text between the given start and end positions.
+        Returns the modified text and the deleted text.
+        """
+        del_start_idx = TextUtils.get_index_from_line_col(text, start_line, start_col)
+        del_end_idx = TextUtils.get_index_from_line_col(text, end_line, end_col)
+
+        deleted_text = text[del_start_idx:del_end_idx]
+        new_text = text[:del_start_idx] + text[del_end_idx:]
+        return new_text, deleted_text
+
+    @staticmethod
+    def insert_text_at_position(text: str, line: int, col: int, text_to_be_inserted: str) -> tuple[str, int, int]:
+        """
+        Inserts the given text at the given line and column.
+        Returns the modified text and the new line and column.
+        """
+        try:
+            change_index = TextUtils.get_index_from_line_col(text, line, col)
+        except InvalidTextLocationError:
+            num_lines_in_text = text.count("\n") + 1
+            max_line = num_lines_in_text - 1
+            if line == max_line + 1 and col == 0:  # trying to insert at new line after full text
+                # insert at end, adding missing newline
+                change_index = len(text)
+                text_to_be_inserted = "\n" + text_to_be_inserted
+            else:
+                raise
+        new_text = text[:change_index] + text_to_be_inserted + text[change_index:]
+        new_l, new_c = TextUtils._get_updated_position_from_line_and_column_and_edit(line, col, text_to_be_inserted)
+        return new_text, new_l, new_c
+
+
+class PathUtils:
+    """
+    Utilities for platform-agnostic path operations.
+    """
+
+    @staticmethod
+    def uri_to_path(uri: str) -> str:
+        """
+        Converts a URI to a file path. Works on both Linux and Windows.
+
+        This method was obtained from https://stackoverflow.com/a/61922504
+        """
+        try:
+            from urllib.parse import unquote, urlparse
+            from urllib.request import url2pathname
+        except ImportError:
+            # backwards compatibility
+            from urllib import unquote, url2pathname
+
+            from urlparse import urlparse
+        parsed = urlparse(uri)
+        host = f"{os.path.sep}{os.path.sep}{parsed.netloc}{os.path.sep}"
+        path = os.path.normpath(os.path.join(host, url2pathname(unquote(parsed.path))))
+        return path
+
+    @staticmethod
+    def path_to_uri(path: str) -> str:
+        """
+        Converts a file path to a file URI (file:///...).
+        """
+        return str(Path(path).absolute().as_uri())
+
+    @staticmethod
+    def is_glob_pattern(pattern: str) -> bool:
+        """Check if a pattern contains glob-specific characters."""
+        return any(c in pattern for c in "*?[]!")
+
+    @staticmethod
+    def get_relative_path(path: str, base_path: str) -> str | None:
+        """
+        Gets relative path if it's possible (paths should be on the same drive),
+        returns `None` otherwise.
+        """
+        if PurePath(path).drive == PurePath(base_path).drive:
+            rel_path = str(PurePath(os.path.relpath(path, base_path)))
+            return rel_path
+        return None
+
+
+class FileUtils:
+    """
+    Utility functions for file operations.
+    """
+
+    @staticmethod
+    def read_file(logger: LanguageServerLogger, file_path: str) -> str:
+        """
+        Reads the file at the given path and returns the contents as a string.
+        """
+        if not os.path.exists(file_path):
+            logger.log(f"File read '{file_path}' failed: File does not exist.", logging.ERROR)
+            raise SolidLSPException(f"File read '{file_path}' failed: File does not exist.")
+        try:
+            with open(file_path, encoding="utf-8") as inp_file:
+                return inp_file.read()
+        except Exception as exc:
+            logger.log(f"File read '{file_path}' failed to read with encoding 'utf-8': {exc}", logging.ERROR)
+            raise SolidLSPException("File read failed.") from None
+
+    @staticmethod
+    def download_file(logger: LanguageServerLogger, url: str, target_path: str) -> None:
+        """
+        Downloads the file from the given URL to the given {target_path}
+        """
+        os.makedirs(os.path.dirname(target_path), exist_ok=True)
+        try:
+            response = requests.get(url, stream=True, timeout=60)
+            if response.status_code != 200:
+                logger.log(f"Error downloading file '{url}': {response.status_code} {response.text}", logging.ERROR)
+                raise SolidLSPException("Error downloading file.")
+            with open(target_path, "wb") as f:
+                shutil.copyfileobj(response.raw, f)
+        except Exception as exc:
+            logger.log(f"Error downloading file '{url}': {exc}", logging.ERROR)
+            raise SolidLSPException("Error downloading file.") from None
+
+    @staticmethod
+    def download_and_extract_archive(logger: LanguageServerLogger, url: str, target_path: str, archive_type: str) -> None:
+        """
+        Downloads the archive from the given URL having format {archive_type} and extracts it to the given {target_path}
+        """
+        try:
+            tmp_files = []
+            tmp_file_name = str(PurePath(os.path.expanduser("~"), "multilspy_tmp", uuid.uuid4().hex))
+            tmp_files.append(tmp_file_name)
+            os.makedirs(os.path.dirname(tmp_file_name), exist_ok=True)
+            FileUtils.download_file(logger, url, tmp_file_name)
+            if archive_type in ["tar", "gztar", "bztar", "xztar"]:
+                os.makedirs(target_path, exist_ok=True)
+                shutil.unpack_archive(tmp_file_name, target_path, archive_type)
+            elif archive_type == "zip":
+                os.makedirs(target_path, exist_ok=True)
+                with zipfile.ZipFile(tmp_file_name, "r") as zip_ref:
+                    for zip_info in zip_ref.infolist():
+                        extracted_path = zip_ref.extract(zip_info, target_path)
+                        ZIP_SYSTEM_UNIX = 3  # zip file created on Unix system
+                        if zip_info.create_system != ZIP_SYSTEM_UNIX:
+                            continue
+                        # extractall() does not preserve permissions
+                        # see. https://github.com/python/cpython/issues/59999
+                        attrs = (zip_info.external_attr >> 16) & 0o777
+                        if attrs:
+                            os.chmod(extracted_path, attrs)
+            elif archive_type == "zip.gz":
+                os.makedirs(target_path, exist_ok=True)
+                tmp_file_name_ungzipped = tmp_file_name + ".zip"
+                tmp_files.append(tmp_file_name_ungzipped)
+                with gzip.open(tmp_file_name, "rb") as f_in, open(tmp_file_name_ungzipped, "wb") as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+                shutil.unpack_archive(tmp_file_name_ungzipped, target_path, "zip")
+            elif archive_type == "gz":
+                with gzip.open(tmp_file_name, "rb") as f_in, open(target_path, "wb") as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+            else:
+                logger.log(f"Unknown archive type '{archive_type}' for extraction", logging.ERROR)
+                raise SolidLSPException(f"Unknown archive type '{archive_type}'")
+        except Exception as exc:
+            logger.log(f"Error extracting archive '{tmp_file_name}' obtained from '{url}': {exc}", logging.ERROR)
+            raise SolidLSPException("Error extracting archive.") from exc
+        finally:
+            for tmp_file_name in tmp_files:
+                if os.path.exists(tmp_file_name):
+                    Path.unlink(Path(tmp_file_name))
+
+
+class PlatformId(str, Enum):
+    """
+    multilspy supported platforms
+    """
+
+    WIN_x86 = "win-x86"
+    WIN_x64 = "win-x64"
+    WIN_arm64 = "win-arm64"
+    OSX = "osx"
+    OSX_x64 = "osx-x64"
+    OSX_arm64 = "osx-arm64"
+    LINUX_x86 = "linux-x86"
+    LINUX_x64 = "linux-x64"
+    LINUX_arm64 = "linux-arm64"
+    LINUX_MUSL_x64 = "linux-musl-x64"
+    LINUX_MUSL_arm64 = "linux-musl-arm64"
+
+    def is_windows(self):
+        return self.value.startswith("win")
+
+
+class DotnetVersion(str, Enum):
+    """
+    multilspy supported dotnet versions
+    """
+
+    V4 = "4"
+    V6 = "6"
+    V7 = "7"
+    V8 = "8"
+    V9 = "9"
+    VMONO = "mono"
+
+
+class PlatformUtils:
+    """
+    This class provides utilities for platform detection and identification.
+    """
+
+    @classmethod
+    def get_platform_id(cls) -> PlatformId:
+        """
+        Returns the platform id for the current system
+        """
+        system = platform.system()
+        machine = platform.machine()
+        bitness = platform.architecture()[0]
+        if system == "Windows" and machine == "":
+            machine = cls._determine_windows_machine_type()
+        system_map = {"Windows": "win", "Darwin": "osx", "Linux": "linux"}
+        machine_map = {
+            "AMD64": "x64",
+            "x86_64": "x64",
+            "i386": "x86",
+            "i686": "x86",
+            "aarch64": "arm64",
+            "arm64": "arm64",
+            "ARM64": "arm64",
+        }
+        if system in system_map and machine in machine_map:
+            platform_id = system_map[system] + "-" + machine_map[machine]
+            if system == "Linux" and bitness == "64bit":
+                libc = platform.libc_ver()[0]
+                if libc != "glibc":
+                    platform_id += "-" + libc
+            return PlatformId(platform_id)
+        else:
+            raise SolidLSPException(f"Unknown platform: {system=}, {machine=}, {bitness=}")
+
+    @staticmethod
+    def _determine_windows_machine_type():
+        import ctypes
+        from ctypes import wintypes
+
+        class SYSTEM_INFO(ctypes.Structure):
+            class _U(ctypes.Union):
+                class _S(ctypes.Structure):
+                    _fields_ = [("wProcessorArchitecture", wintypes.WORD), ("wReserved", wintypes.WORD)]
+
+                _fields_ = [("dwOemId", wintypes.DWORD), ("s", _S)]
+                _anonymous_ = ("s",)
+
+            _fields_ = [
+                ("u", _U),
+                ("dwPageSize", wintypes.DWORD),
+                ("lpMinimumApplicationAddress", wintypes.LPVOID),
+                ("lpMaximumApplicationAddress", wintypes.LPVOID),
+                ("dwActiveProcessorMask", wintypes.LPVOID),
+                ("dwNumberOfProcessors", wintypes.DWORD),
+                ("dwProcessorType", wintypes.DWORD),
+                ("dwAllocationGranularity", wintypes.DWORD),
+                ("wProcessorLevel", wintypes.WORD),
+                ("wProcessorRevision", wintypes.WORD),
+            ]
+            _anonymous_ = ("u",)
+
+        sys_info = SYSTEM_INFO()
+        ctypes.windll.kernel32.GetNativeSystemInfo(ctypes.byref(sys_info))
+
+        arch_map = {
+            9: "AMD64",
+            5: "ARM",
+            12: "arm64",
+            6: "Intel Itanium-based",
+            0: "i386",
+        }
+
+        return arch_map.get(sys_info.wProcessorArchitecture, f"Unknown ({sys_info.wProcessorArchitecture})")
+
+    @staticmethod
+    def get_dotnet_version() -> DotnetVersion:
+        """
+        Returns the dotnet version for the current system
+        """
+        try:
+            result = subprocess.run(["dotnet", "--list-runtimes"], capture_output=True, check=True)
+            available_version_cmd_output = []
+            for line in result.stdout.decode("utf-8").split("\n"):
+                if line.startswith("Microsoft.NETCore.App"):
+                    version_cmd_output = line.split(" ")[1]
+                    available_version_cmd_output.append(version_cmd_output)
+
+            if not available_version_cmd_output:
+                raise SolidLSPException("dotnet not found on the system")
+
+            # Check for supported versions in order of preference (latest first)
+            for version_cmd_output in available_version_cmd_output:
+                if version_cmd_output.startswith("9"):
+                    return DotnetVersion.V9
+                if version_cmd_output.startswith("8"):
+                    return DotnetVersion.V8
+                if version_cmd_output.startswith("7"):
+                    return DotnetVersion.V7
+                if version_cmd_output.startswith("6"):
+                    return DotnetVersion.V6
+                if version_cmd_output.startswith("4"):
+                    return DotnetVersion.V4
+
+            # If no supported version found, raise exception with all available versions
+            raise SolidLSPException(
+                f"No supported dotnet version found. Available versions: {', '.join(available_version_cmd_output)}. Supported versions: 4, 6, 7, 8"
+            )
+        except (FileNotFoundError, subprocess.CalledProcessError):
+            try:
+                result = subprocess.run(["mono", "--version"], capture_output=True, check=True)
+                return DotnetVersion.VMONO
+            except (FileNotFoundError, subprocess.CalledProcessError):
+                raise SolidLSPException("dotnet or mono not found on the system")
+
+
+class SymbolUtils:
+    @staticmethod
+    def symbol_tree_contains_name(roots: list[UnifiedSymbolInformation], name: str) -> bool:
+        for symbol in roots:
+            if symbol["name"] == name:
+                return True
+            if SymbolUtils.symbol_tree_contains_name(symbol["children"], name):
+                return True
+        return False

projects/ui/serena-new/src/solidlsp/settings.py

@@ -0,0 +1,29 @@
+"""
+Defines settings for Solid-LSP
+"""
+
+import os
+import pathlib
+from dataclasses import dataclass
+
+
+@dataclass
+class SolidLSPSettings:
+    solidlsp_dir: str = str(pathlib.Path.home() / ".solidlsp")
+    """
+    Path to the directory in which to store global Solid-LSP data (which is not project-specific)
+    """
+    project_data_relative_path: str = ".solidlsp"
+    """
+    Relative path within each project directory where Solid-LSP can store project-specific data, e.g. cache files.
+    For instance, if this is ".solidlsp" and the project is located at "/home/user/myproject",
+    then Solid-LSP will store project-specific data in "/home/user/myproject/.solidlsp".
+    """
+
+    def __post_init__(self):
+        os.makedirs(str(self.solidlsp_dir), exist_ok=True)
+        os.makedirs(str(self.ls_resources_dir), exist_ok=True)
+
+    @property
+    def ls_resources_dir(self):
+        return os.path.join(str(self.solidlsp_dir), "language_servers", "static")