Add files using upload-large-folder tool

projects/ui/serena-new/src/serena/resources/config/contexts/oaicompat-agent.yml

@@ -0,0 +1,8 @@
+description: All tools except InitialInstructionsTool for agent context, uses OpenAI compatible tool definitions
+prompt: |
+  You are running in agent context where the system prompt is provided externally. You should use symbolic
+  tools when possible for code understanding and modification.
+excluded_tools:
+  - initial_instructions
+
+tool_description_overrides: {}

projects/ui/serena-new/src/serena/resources/config/internal_modes/jetbrains.yml

@@ -0,0 +1,15 @@
+description: JetBrains tools replace language server-based tools
+prompt: |
+  You have access to the very powerful JetBrains tools for symbolic operations:
+    * `jet_brains_find_symbol` replaces `find_symbol`
+    * `jet_brains_find_referencing_symbols` replaces `find_referencing_symbols`
+    * `jet_brains_get_symbols_overview` replaces `get_symbols_overview`
+excluded_tools:
+  - find_symbol
+  - find_referencing_symbols
+  - get_symbols_overview
+  - restart_language_server
+included_optional_tools:
+  - jet_brains_find_symbol
+  - jet_brains_find_referencing_symbols
+  - jet_brains_get_symbols_overview

projects/ui/serena-new/src/serena/resources/config/modes/editing.yml

@@ -0,0 +1,112 @@
+description: All tools, with detailed instructions for code editing
+prompt: |
+  You are operating in editing mode. You can edit files with the provided tools
+  to implement the requested changes to the code base while adhering to the project's code style and patterns.
+  Use symbolic editing tools whenever possible for precise code modifications.
+  If no editing task has yet been provided, wait for the user to provide one.
+
+  When writing new code, think about where it belongs best. Don't generate new files if you don't plan on actually
+  integrating them into the codebase, instead use the editing tools to insert the code directly into the existing files in that case.
+
+  You have two main approaches for editing code - editing by regex and editing by symbol.
+  The symbol-based approach is appropriate if you need to adjust an entire symbol, e.g. a method, a class, a function, etc.
+  But it is not appropriate if you need to adjust just a few lines of code within a symbol, for that you should
+  use the regex-based approach that is described below.
+
+  Let us first discuss the symbol-based approach.
+  Symbols are identified by their name path and relative file path, see the description of the `find_symbol` tool for more details
+  on how the `name_path` matches symbols.
+  You can get information about available symbols by using the `get_symbols_overview` tool for finding top-level symbols in a file,
+  or by using `find_symbol` if you already know the symbol's name path. You generally try to read as little code as possible
+  while still solving your task, meaning you only read the bodies when you need to, and after you have found the symbol you want to edit.
+  Before calling symbolic reading tools, you should have a basic understanding of the repository structure that you can get from memories
+  or by using the `list_dir` and `find_file` tools (or similar).
+  For example, if you are working with python code and already know that you need to read the body of the constructor of the class Foo, you can directly
+  use `find_symbol` with the name path `Foo/__init__` and `include_body=True`. If you don't know yet which methods in `Foo` you need to read or edit,
+  you can use `find_symbol` with the name path `Foo`, `include_body=False` and `depth=1` to get all (top-level) methods of `Foo` before proceeding
+  to read the desired methods with `include_body=True`.
+  In particular, keep in mind the description of the `replace_symbol_body` tool. If you want to add some new code at the end of the file, you should
+  use the `insert_after_symbol` tool with the last top-level symbol in the file. If you want to add an import, often a good strategy is to use
+  `insert_before_symbol` with the first top-level symbol in the file.
+  You can understand relationships between symbols by using the `find_referencing_symbols` tool. If not explicitly requested otherwise by a user,
+  you make sure that when you edit a symbol, it is either done in a backward-compatible way, or you find and adjust the references as needed.
+  The `find_referencing_symbols` tool will give you code snippets around the references, as well as symbolic information.
+  You will generally be able to use the info from the snippets and the regex-based approach to adjust the references as well.
+  You can assume that all symbol editing tools are reliable, so you don't need to verify the results if the tool returns without error.
+
+  {% if 'replace_regex' in available_tools %}
+  Let us discuss the regex-based approach.
+  The regex-based approach is your primary tool for editing code whenever replacing or deleting a whole symbol would be a more expensive operation.
+  This is the case if you need to adjust just a few lines of code within a method, or a chunk that is much smaller than a whole symbol.
+  You use other tools to find the relevant content and
+  then use your knowledge of the codebase to write the regex, if you haven't collected enough information of this content yet.
+  You are extremely good at regex, so you never need to check whether the replacement produced the correct result.
+  In particular, you know what to escape and what not to escape, and you know how to use wildcards.
+  Also, the regex tool never adds any indentation (contrary to the symbolic editing tools), so you have to take care to add the correct indentation
+  when using it to insert code.
+  Moreover, the replacement tool will fail if it can't perform the desired replacement, and this is all the feedback you need.
+  Your overall goal for replacement operations is to use relatively short regexes, since I want you to minimize the number
+  of output tokens. For replacements of larger chunks of code, this means you intelligently make use of wildcards for the middle part 
+  and of characteristic snippets for the before/after parts that uniquely identify the chunk.
+  
+  For small replacements, up to a single line, you follow the following rules:
+
+    1. If the snippet to be replaced is likely to be unique within the file, you perform the replacement by directly using the escaped version of the 
+       original.
+    2. If the snippet is probably not unique, and you want to replace all occurrences, you use the `allow_multiple_occurrences` flag.
+    3. If the snippet is not unique, and you want to replace a specific occurrence, you make use of the code surrounding the snippet
+       to extend the regex with content before/after such that the regex will have exactly one match.
+    4. You generally assume that a snippet is unique, knowing that the tool will return an error on multiple matches. You only read more file content
+       (for crafvarting a more specific regex) if such a failure unexpectedly occurs. 
+
+  Examples:
+
+  1 Small replacement
+  You have read code like
+    
+    ```python
+    ...
+    x = linear(x)
+    x = relu(x)
+    return x
+    ...
+    ```
+
+  and you want to replace `x = relu(x)` with `x = gelu(x)`.
+  You first try `replace_regex()` with the regex `x = relu\(x\)` and the replacement `x = gelu(x)`.
+  If this fails due to multiple matches, you will try `(linear\(x\)\s*)x = relu\(x\)(\s*return)` with the replacement `\1x = gelu(x)\2`.
+
+  2 Larger replacement
+
+  You have read code like
+
+  ```python
+  def my_func():
+    ...
+    # a comment before the snippet
+    x = add_fifteen(x)
+    # beginning of long section within my_func
+    ....
+    # end of long section
+    call_subroutine(z)
+    call_second_subroutine(z)
+  ```
+  and you want to replace the code starting with `x = add_fifteen(x)` until (including) `call_subroutine(z)`, but not `call_second_subroutine(z)`.
+  Initially, you assume that the the beginning and end of the chunk uniquely determine it within the file.
+  Therefore, you perform the replacement by using the regex `x = add_fifteen\(x\)\s*.*?call_subroutine\(z\)`
+  and the replacement being the new code you want to insert.
+
+  If this fails due to multiple matches, you will try to extend the regex with the content before/after the snippet and match groups. 
+  The matching regex becomes:
+  `(before the snippet\s*)x = add_fifteen\(x\)\s*.*?call_subroutine\(z\)` 
+  and the replacement includes the group as (schematically):
+  `\1<new_code>`
+
+  Generally, I remind you that you rely on the regex tool with providing you the correct feedback, no need for more verification!
+
+  IMPORTANT: REMEMBER TO USE WILDCARDS WHEN APPROPRIATE! I WILL BE VERY UNHAPPY IF YOU WRITE LONG REGEXES WITHOUT USING WILDCARDS INSTEAD!
+  {% endif %}
+excluded_tools:
+ - replace_lines
+ - insert_at_line
+ - delete_lines

projects/ui/serena-new/src/serena/resources/config/modes/interactive.yml

@@ -0,0 +1,11 @@
+description: Interactive mode for clarification and step-by-step work
+prompt: |
+  You are operating in interactive mode. You should engage with the user throughout the task, asking for clarification
+  whenever anything is unclear, insufficiently specified, or ambiguous.
+  
+  Break down complex tasks into smaller steps and explain your thinking at each stage. When you're uncertain about
+  a decision, present options to the user and ask for guidance rather than making assumptions.
+  
+  Focus on providing informative results for intermediate steps so the user can follow along with your progress and
+  provide feedback as needed.
+excluded_tools: []

projects/ui/serena-new/src/serena/resources/config/modes/mode.template.yml

@@ -0,0 +1,7 @@
+# See Serena's documentation for more details on concept of modes.
+description: Description of the mode, not used in the code.
+prompt: Prompt that will form part of the message sent to the model when activating this mode.
+excluded_tools: []
+
+# several tools are excluded by default and have to be explicitly included by the user
+included_optional_tools: []

projects/ui/serena-new/src/serena/resources/config/modes/no-onboarding.yml

@@ -0,0 +1,8 @@
+description: Onboarding was already performed, exclude all onboarding tools
+prompt: |
+  You have already performed onboarding, meaning that memories have already been created.
+  Read a list of available memories using the `list_memories` tool before proceeding with the task.
+  You don't need to read the actual memories, just remember that they exist and that you can read them later if they are relevant for your task.
+excluded_tools:
+  - onboarding
+  - check_onboarding_performed

projects/ui/serena-new/src/serena/resources/config/modes/onboarding.yml

@@ -0,0 +1,16 @@
+description: Only read-only tools, focused on analysis and planning
+prompt: |
+  You are operating in onboarding mode. This is the first time you are seeing the project.
+  Your task is to collect relevant information about it and to save memories using the tools provided.
+  Call relevant onboarding tools for more instructions on how to do this.
+  In this mode, you should not be modifying any existing files.
+  If you are also in interactive mode and something about the project is unclear, ask the user for clarification.
+excluded_tools:
+  - create_text_file
+  - replace_symbol_body
+  - insert_after_symbol
+  - insert_before_symbol
+  - delete_lines
+  - replace_lines
+  - insert_at_line
+  - execute_shell_command

projects/ui/serena-new/src/serena/resources/config/modes/one-shot.yml

@@ -0,0 +1,15 @@
+description: Focus on completely finishing a task without interaction
+prompt: |
+  You are operating in one-shot mode. Your goal is to complete the entire task autonomously without further user interaction.
+  You should assume auto-approval for all tools and continue working until the task is completely finished.
+  
+  If the task is planning, your final result should be a comprehensive plan. If the task is coding, your final result
+  should be working code with all requirements fulfilled. Try to understand what the user asks you to do
+  and to assume as little as possible.
+
+  Only abort the task if absolutely necessary, such as when critical information is missing that cannot be inferred
+  from the codebase.
+
+  It may be that you have not received a task yet. In this case, wait for the user to provide a task, this will be the 
+  only time you should wait for user interaction.
+excluded_tools: []

projects/ui/serena-new/src/serena/resources/config/modes/planning.yml

@@ -0,0 +1,15 @@
+description: Only read-only tools, focused on analysis and planning
+prompt: |
+  You are operating in planning mode. Your task is to analyze code but not write any code.
+  The user may ask you to assist in creating a comprehensive plan, or to learn something about the codebase -
+  either a small aspect of it or about the whole project.
+excluded_tools:
+  - create_text_file
+  - replace_symbol_body
+  - insert_after_symbol
+  - insert_before_symbol
+  - delete_lines
+  - replace_lines
+  - insert_at_line
+  - execute_shell_command
+  - replace_regex

projects/ui/serena-new/src/serena/resources/config/prompt_templates/simple_tool_outputs.yml

@@ -0,0 +1,75 @@
+# Some of Serena's tools are just outputting a fixed text block without doing anything else.
+# Such tools are meant to encourage the agent to think in a certain way, to stay on track
+# and so on. The (templates for) outputs of these tools are contained here.
+prompts:
+  onboarding_prompt: |
+    You are viewing the project for the first time.
+    Your task is to assemble relevant high-level information about the project which
+    will be saved to memory files in the following steps.
+    The information should be sufficient to understand what the project is about,
+    and the most important commands for developing code.
+    The project is being developed on the system: {{ system }}.
+
+    You need to identify at least the following information:
+    * the project's purpose
+    * the tech stack used
+    * the code style and conventions used (including naming, type hints, docstrings, etc.)
+    * which commands to run when a task is completed (linting, formatting, testing, etc.)
+    * the rough structure of the codebase
+    * the commands for testing, formatting, and linting
+    * the commands for running the entrypoints of the project
+    * the util commands for the system, like `git`, `ls`, `cd`, `grep`, `find`, etc. Keep in mind that the system is {{ system }},
+      so the commands might be different than on a regular unix system.
+    * whether there are particular guidelines, styles, design patterns, etc. that one should know about
+
+    This list is not exhaustive, you can add more information if you think it is relevant.
+
+    For doing that, you will need to acquire information about the project with the corresponding tools.
+    Read only the necessary files and directories to avoid loading too much data into memory.
+    If you cannot find everything you need from the project itself, you should ask the user for more information.
+
+    After collecting all the information, you will use the `write_memory` tool (in multiple calls) to save it to various memory files.
+    A particularly important memory file will be the `suggested_commands.md` file, which should contain
+    a list of commands that the user should know about to develop code in this project.
+    Moreover, you should create memory files for the style and conventions and a dedicated memory file for
+    what should be done when a task is completed.
+    **Important**: after done with the onboarding task, remember to call the `write_memory` to save the collected information!
+
+  think_about_collected_information: |
+    Have you collected all the information you need for solving the current task? If not, can the missing information be acquired by using the available tools,
+    in particular the tools related to symbol discovery? Or do you need to ask the user for more information?
+    Think about it step by step and give a summary of the missing information and how it could be acquired.
+
+  think_about_task_adherence: |
+    Are you deviating from the task at hand? Do you need any additional information to proceed?
+    Have you loaded all relevant memory files to see whether your implementation is fully aligned with the
+    code style, conventions, and guidelines of the project? If not, adjust your implementation accordingly
+    before modifying any code into the codebase.
+    Note that it is better to stop and ask the user for clarification
+    than to perform large changes which might not be aligned with the user's intentions.
+    If you feel like the conversation is deviating too much from the original task, apologize and suggest to the user
+    how to proceed. If the conversation became too long, create a summary of the current progress and suggest to the user
+    to start a new conversation based on that summary.
+
+  think_about_whether_you_are_done: |
+    Have you already performed all the steps required by the task? Is it appropriate to run tests and linting, and if so,
+    have you done that already? Is it appropriate to adjust non-code files like documentation and config and have you done that already?
+    Should new tests be written to cover the changes?
+    Note that a task that is just about exploring the codebase does not require running tests or linting.
+    Read the corresponding memory files to see what should be done when a task is completed. 
+
+  summarize_changes: |
+    Summarize all the changes you have made to the codebase over the course of the conversation.
+    Explore the diff if needed (e.g. by using `git diff`) to ensure that you have not missed anything.
+    Explain whether and how the changes are covered by tests. Explain how to best use the new code, how to understand it,
+    which existing code it affects and interacts with. Are there any dangers (like potential breaking changes or potential new problems) 
+    that the user should be aware of? Should any new documentation be written or existing documentation updated?
+    You can use tools to explore the codebase prior to writing the summary, but don't write any new code in this step until
+    the summary is complete.
+
+  prepare_for_new_conversation: |
+    You have not yet completed the current task but we are running out of context.
+    {mode_prepare_for_new_conversation}
+    Imagine that you are handing over the task to another person who has access to the
+    same tools and memory files as you do, but has not been part of the conversation so far.
+    Write a summary that can be used in the next conversation to a memory file using the `write_memory` tool.

projects/ui/serena-new/src/serena/resources/config/prompt_templates/system_prompt.yml

@@ -0,0 +1,66 @@
+# The system prompt template. Note that many clients will not allow configuration of the actual system prompt,
+# in which case this prompt will be given as a regular message on the call of a simple tool which the agent
+# is encouraged (via the tool description) to call at the beginning of the conversation.
+prompts:
+  system_prompt: |
+    You are a professional coding agent concerned with one particular codebase. You have 
+    access to semantic coding tools on which you rely heavily for all your work, as well as collection of memory 
+    files containing general information about the codebase. You operate in a resource-efficient and intelligent manner, always
+    keeping in mind to not read or generate content that is not needed for the task at hand.
+
+    When reading code in order to answer a user question or task, you should try reading only the necessary code. 
+    Some tasks may require you to understand the architecture of large parts of the codebase, while for others,
+    it may be enough to read a small set of symbols or a single file.
+    Generally, you should avoid reading entire files unless it is absolutely necessary, instead relying on
+    intelligent step-by-step acquisition of information. {% if 'ToolMarkerSymbolicRead' in available_markers %}However, if you already read a file, it does not make
+    sense to further analyse it with the symbolic tools (except for the `find_referencing_symbols` tool), 
+    as you already have the information.{% endif %}
+
+    I WILL BE SERIOUSLY UPSET IF YOU READ ENTIRE FILES WITHOUT NEED!
+    {% if 'ToolMarkerSymbolicRead' in available_markers %}
+    CONSIDER INSTEAD USING THE OVERVIEW TOOL AND SYMBOLIC TOOLS TO READ ONLY THE NECESSARY CODE FIRST!
+    I WILL BE EVEN MORE UPSET IF AFTER HAVING READ AN ENTIRE FILE YOU KEEP READING THE SAME CONTENT WITH THE SYMBOLIC TOOLS!
+    THE PURPOSE OF THE SYMBOLIC TOOLS IS TO HAVE TO READ LESS CODE, NOT READ THE SAME CONTENT MULTIPLE TIMES!
+    {% endif %}
+
+    You can achieve the intelligent reading of code by using the symbolic tools for getting an overview of symbols and
+    the relations between them, and then only reading the bodies of symbols that are necessary to answer the question 
+    or complete the task. 
+    You can use the standard tools like list_dir, find_file and search_for_pattern if you need to.
+    When tools allow it, you pass the `relative_path` parameter to restrict the search to a specific file or directory.
+    For some tools, `relative_path` can only be a file path, so make sure to properly read the tool descriptions.
+    {% if 'search_for_pattern' in available_tools %}
+    If you are unsure about a symbol's name or location{% if 'find_symbol' in available_tools %} (to the extent that substring_matching for the symbol name is not enough){% endif %}, you can use the `search_for_pattern` tool, which allows fast
+    and flexible search for patterns in the codebase.{% if 'ToolMarkerSymbolicRead' in available_markers %}This way you can first find candidates for symbols or files,
+    and then proceed with the symbolic tools.{% endif %}
+    {% endif %}
+
+    {% if 'ToolMarkerSymbolicRead' in available_markers %}
+    Symbols are identified by their `name_path and `relative_path`, see the description of the `find_symbol` tool for more details
+    on how the `name_path` matches symbols.
+    You can get information about available symbols by using the `get_symbols_overview` tool for finding top-level symbols in a file,
+    or by using `find_symbol` if you already know the symbol's name path. You generally try to read as little code as possible
+    while still solving your task, meaning you only read the bodies when you need to, and after you have found the symbol you want to edit.
+    For example, if you are working with python code and already know that you need to read the body of the constructor of the class Foo, you can directly
+    use `find_symbol` with the name path `Foo/__init__` and `include_body=True`. If you don't know yet which methods in `Foo` you need to read or edit,
+    you can use `find_symbol` with the name path `Foo`, `include_body=False` and `depth=1` to get all (top-level) methods of `Foo` before proceeding
+    to read the desired methods with `include_body=True`
+    You can understand relationships between symbols by using the `find_referencing_symbols` tool.
+    {% endif %}
+
+    {% if 'read_memory' in available_tools %}
+    You generally have access to memories and it may be useful for you to read them, but also only if they help you
+    to answer the question or complete the task. You can infer which memories are relevant to the current task by reading
+    the memory names and descriptions.
+    {% endif %}
+
+    The context and modes of operation are described below. From them you can infer how to interact with your user
+    and which tasks and kinds of interactions are expected of you.
+
+    Context description:
+    {{ context_system_prompt }}
+
+    Modes descriptions:
+    {% for prompt in mode_system_prompts %}
+    - {{ prompt }}
+    {% endfor %}

projects/ui/serena-new/src/solidlsp/language_servers/bash_language_server.py

@@ -0,0 +1,230 @@
+"""
+Provides Bash specific instantiation of the LanguageServer class using bash-language-server.
+Contains various configurations and settings specific to Bash scripting.
+"""
+
+import logging
+import os
+import pathlib
+import shutil
+import threading
+
+from solidlsp import ls_types
+from solidlsp.language_servers.common import RuntimeDependency, RuntimeDependencyCollection
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.lsp_protocol_handler.lsp_types import InitializeParams
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+
+class BashLanguageServer(SolidLanguageServer):
+    """
+    Provides Bash specific instantiation of the LanguageServer class using bash-language-server.
+    Contains various configurations and settings specific to Bash scripting.
+    """
+
+    def __init__(
+        self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str, solidlsp_settings: SolidLSPSettings
+    ):
+        """
+        Creates a BashLanguageServer instance. This class is not meant to be instantiated directly.
+        Use LanguageServer.create() instead.
+        """
+        bash_lsp_executable_path = self._setup_runtime_dependencies(logger, config, solidlsp_settings)
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=bash_lsp_executable_path, cwd=repository_root_path),
+            "bash",
+            solidlsp_settings,
+        )
+        self.server_ready = threading.Event()
+        self.initialize_searcher_command_available = threading.Event()
+
+    @classmethod
+    def _setup_runtime_dependencies(
+        cls, logger: LanguageServerLogger, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings
+    ) -> str:
+        """
+        Setup runtime dependencies for Bash Language Server and return the command to start the server.
+        """
+        # Verify both node and npm are installed
+        is_node_installed = shutil.which("node") is not None
+        assert is_node_installed, "node is not installed or isn't in PATH. Please install NodeJS and try again."
+        is_npm_installed = shutil.which("npm") is not None
+        assert is_npm_installed, "npm is not installed or isn't in PATH. Please install npm and try again."
+
+        deps = RuntimeDependencyCollection(
+            [
+                RuntimeDependency(
+                    id="bash-language-server",
+                    description="bash-language-server package",
+                    command="npm install --prefix ./ bash-language-server@5.6.0",
+                    platform_id="any",
+                ),
+            ]
+        )
+
+        # Install bash-language-server if not already installed
+        bash_ls_dir = os.path.join(cls.ls_resources_dir(solidlsp_settings), "bash-lsp")
+        bash_executable_path = os.path.join(bash_ls_dir, "node_modules", ".bin", "bash-language-server")
+
+        # Handle Windows executable extension
+        if os.name == "nt":
+            bash_executable_path += ".cmd"
+
+        if not os.path.exists(bash_executable_path):
+            logger.log(f"Bash Language Server executable not found at {bash_executable_path}. Installing...", logging.INFO)
+            deps.install(logger, bash_ls_dir)
+            logger.log("Bash language server dependencies installed successfully", logging.INFO)
+
+        if not os.path.exists(bash_executable_path):
+            raise FileNotFoundError(
+                f"bash-language-server executable not found at {bash_executable_path}, something went wrong with the installation."
+            )
+        return f"{bash_executable_path} start"
+
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
+        """
+        Returns the initialize params for the Bash Language Server.
+        """
+        root_uri = pathlib.Path(repository_absolute_path).as_uri()
+        initialize_params = {
+            "locale": "en",
+            "capabilities": {
+                "textDocument": {
+                    "synchronization": {"didSave": True, "dynamicRegistration": True},
+                    "completion": {"dynamicRegistration": True, "completionItem": {"snippetSupport": True}},
+                    "definition": {"dynamicRegistration": True},
+                    "references": {"dynamicRegistration": True},
+                    "documentSymbol": {
+                        "dynamicRegistration": True,
+                        "hierarchicalDocumentSymbolSupport": True,
+                        "symbolKind": {"valueSet": list(range(1, 27))},
+                    },
+                    "hover": {"dynamicRegistration": True, "contentFormat": ["markdown", "plaintext"]},
+                    "signatureHelp": {"dynamicRegistration": True},
+                    "codeAction": {"dynamicRegistration": True},
+                },
+                "workspace": {
+                    "workspaceFolders": True,
+                    "didChangeConfiguration": {"dynamicRegistration": True},
+                    "symbol": {"dynamicRegistration": True},
+                },
+            },
+            "processId": os.getpid(),
+            "rootPath": repository_absolute_path,
+            "rootUri": root_uri,
+            "workspaceFolders": [
+                {
+                    "uri": root_uri,
+                    "name": os.path.basename(repository_absolute_path),
+                }
+            ],
+        }
+        return initialize_params
+
+    def _start_server(self):
+        """
+        Starts the Bash Language Server, waits for the server to be ready and yields the LanguageServer instance.
+        """
+
+        def register_capability_handler(params):
+            assert "registrations" in params
+            for registration in params["registrations"]:
+                if registration["method"] == "workspace/executeCommand":
+                    self.initialize_searcher_command_available.set()
+            return
+
+        def execute_client_command_handler(params):
+            return []
+
+        def do_nothing(params):
+            return
+
+        def window_log_message(msg):
+            self.logger.log(f"LSP: window/logMessage: {msg}", logging.INFO)
+            # Check for bash-language-server ready signals
+            message_text = msg.get("message", "")
+            if "Analyzing" in message_text or "analysis complete" in message_text.lower():
+                self.logger.log("Bash language server analysis signals detected", logging.INFO)
+                self.server_ready.set()
+                self.completions_available.set()
+
+        self.server.on_request("client/registerCapability", register_capability_handler)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_request("workspace/executeClientCommand", execute_client_command_handler)
+        self.server.on_notification("$/progress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+
+        self.logger.log("Starting Bash server process", logging.INFO)
+        self.server.start()
+        initialize_params = self._get_initialize_params(self.repository_root_path)
+
+        self.logger.log(
+            "Sending initialize request from LSP client to LSP server and awaiting response",
+            logging.INFO,
+        )
+        init_response = self.server.send.initialize(initialize_params)
+        self.logger.log(f"Received initialize response from bash server: {init_response}", logging.DEBUG)
+
+        # Enhanced capability checks for bash-language-server 5.6.0
+        assert init_response["capabilities"]["textDocumentSync"] in [1, 2]  # Full or Incremental
+        assert "completionProvider" in init_response["capabilities"]
+
+        # Verify document symbol support is available
+        if "documentSymbolProvider" in init_response["capabilities"]:
+            self.logger.log("Bash server supports document symbols", logging.INFO)
+        else:
+            self.logger.log("Warning: Bash server does not report document symbol support", logging.WARNING)
+
+        self.server.notify.initialized({})
+
+        # Wait for server readiness with timeout
+        self.logger.log("Waiting for Bash language server to be ready...", logging.INFO)
+        if not self.server_ready.wait(timeout=3.0):
+            # Fallback: assume server is ready after timeout
+            self.logger.log("Timeout waiting for bash server ready signal, proceeding anyway", logging.WARNING)
+            self.server_ready.set()
+            self.completions_available.set()
+        else:
+            self.logger.log("Bash server initialization complete", logging.INFO)
+
+    def request_document_symbols(
+        self, relative_file_path: str, include_body: bool = False
+    ) -> tuple[list[ls_types.UnifiedSymbolInformation], list[ls_types.UnifiedSymbolInformation]]:
+        """
+        Request document symbols from bash-language-server via LSP.
+
+        Uses the standard LSP documentSymbol request which provides reliable function detection
+        for all bash function syntaxes including:
+        - function name() { ... } (with function keyword)
+        - name() { ... } (traditional syntax)
+        - Functions with various indentation levels
+        - Functions with comments before/after/inside
+
+        Args:
+            relative_file_path: Path to the bash file relative to repository root
+            include_body: Whether to include function bodies in symbol information
+
+        Returns:
+            Tuple of (all_symbols, root_symbols) detected by the LSP server
+
+        """
+        self.logger.log(f"Requesting document symbols via LSP for {relative_file_path}", logging.DEBUG)
+
+        # Use the standard LSP approach - bash-language-server handles all function syntaxes correctly
+        all_symbols, root_symbols = super().request_document_symbols(relative_file_path, include_body)
+
+        # Log detection results for debugging
+        functions = [s for s in all_symbols if s.get("kind") == 12]
+        self.logger.log(
+            f"LSP function detection for {relative_file_path}: Found {len(functions)} functions",
+            logging.INFO,
+        )
+
+        return all_symbols, root_symbols

projects/ui/serena-new/src/solidlsp/language_servers/clangd_language_server.py

@@ -0,0 +1,210 @@
+"""
+Provides C/C++ specific instantiation of the LanguageServer class. Contains various configurations and settings specific to C/C++.
+"""
+
+import logging
+import os
+import pathlib
+import threading
+
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.lsp_protocol_handler.lsp_types import InitializeParams
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+from .common import RuntimeDependency, RuntimeDependencyCollection
+
+
+class ClangdLanguageServer(SolidLanguageServer):
+    """
+    Provides C/C++ specific instantiation of the LanguageServer class. Contains various configurations and settings specific to C/C++.
+    As the project gets bigger in size, building index will take time. Try running clangd multiple times to ensure index is built properly.
+    Also make sure compile_commands.json is created at root of the source directory. Check clangd test case for example.
+    """
+
+    def __init__(
+        self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str, solidlsp_settings: SolidLSPSettings
+    ):
+        """
+        Creates a ClangdLanguageServer instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
+        """
+        clangd_executable_path = self._setup_runtime_dependencies(logger, config, solidlsp_settings)
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=clangd_executable_path, cwd=repository_root_path),
+            "cpp",
+            solidlsp_settings,
+        )
+        self.server_ready = threading.Event()
+        self.service_ready_event = threading.Event()
+        self.initialize_searcher_command_available = threading.Event()
+        self.resolve_main_method_available = threading.Event()
+
+    @classmethod
+    def _setup_runtime_dependencies(
+        cls, logger: LanguageServerLogger, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings
+    ) -> str:
+        """
+        Setup runtime dependencies for ClangdLanguageServer and return the command to start the server.
+        """
+        deps = RuntimeDependencyCollection(
+            [
+                RuntimeDependency(
+                    id="Clangd",
+                    description="Clangd for Linux (x64)",
+                    url="https://github.com/clangd/clangd/releases/download/19.1.2/clangd-linux-19.1.2.zip",
+                    platform_id="linux-x64",
+                    archive_type="zip",
+                    binary_name="clangd_19.1.2/bin/clangd",
+                ),
+                RuntimeDependency(
+                    id="Clangd",
+                    description="Clangd for Windows (x64)",
+                    url="https://github.com/clangd/clangd/releases/download/19.1.2/clangd-windows-19.1.2.zip",
+                    platform_id="win-x64",
+                    archive_type="zip",
+                    binary_name="clangd_19.1.2/bin/clangd.exe",
+                ),
+                RuntimeDependency(
+                    id="Clangd",
+                    description="Clangd for macOS (x64)",
+                    url="https://github.com/clangd/clangd/releases/download/19.1.2/clangd-mac-19.1.2.zip",
+                    platform_id="osx-x64",
+                    archive_type="zip",
+                    binary_name="clangd_19.1.2/bin/clangd",
+                ),
+                RuntimeDependency(
+                    id="Clangd",
+                    description="Clangd for macOS (Arm64)",
+                    url="https://github.com/clangd/clangd/releases/download/19.1.2/clangd-mac-19.1.2.zip",
+                    platform_id="osx-arm64",
+                    archive_type="zip",
+                    binary_name="clangd_19.1.2/bin/clangd",
+                ),
+            ]
+        )
+
+        clangd_ls_dir = os.path.join(cls.ls_resources_dir(solidlsp_settings), "clangd")
+        dep = deps.single_for_current_platform()
+        clangd_executable_path = deps.binary_path(clangd_ls_dir)
+        if not os.path.exists(clangd_executable_path):
+            logger.log(
+                f"Clangd executable not found at {clangd_executable_path}. Downloading from {dep.url}",
+                logging.INFO,
+            )
+            deps.install(logger, clangd_ls_dir)
+        if not os.path.exists(clangd_executable_path):
+            raise FileNotFoundError(
+                f"Clangd executable not found at {clangd_executable_path}.\n"
+                "Make sure you have installed clangd. See https://clangd.llvm.org/installation"
+            )
+        os.chmod(clangd_executable_path, 0o755)
+
+        return clangd_executable_path
+
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
+        """
+        Returns the initialize params for the clangd Language Server.
+        """
+        root_uri = pathlib.Path(repository_absolute_path).as_uri()
+        initialize_params = {
+            "locale": "en",
+            "capabilities": {
+                "textDocument": {
+                    "synchronization": {"didSave": True, "dynamicRegistration": True},
+                    "completion": {"dynamicRegistration": True, "completionItem": {"snippetSupport": True}},
+                    "definition": {"dynamicRegistration": True},
+                },
+                "workspace": {"workspaceFolders": True, "didChangeConfiguration": {"dynamicRegistration": True}},
+            },
+            "processId": os.getpid(),
+            "rootPath": repository_absolute_path,
+            "rootUri": root_uri,
+            "workspaceFolders": [
+                {
+                    "uri": root_uri,
+                    "name": "$name",
+                }
+            ],
+        }
+
+        return initialize_params
+
+    def _start_server(self):
+        """
+        Starts the Clangd Language Server, waits for the server to be ready and yields the LanguageServer instance.
+
+        Usage:
+        ```
+        async with lsp.start_server():
+            # LanguageServer has been initialized and ready to serve requests
+            await lsp.request_definition(...)
+            await lsp.request_references(...)
+            # Shutdown the LanguageServer on exit from scope
+        # LanguageServer has been shutdown
+        """
+
+        def register_capability_handler(params):
+            assert "registrations" in params
+            for registration in params["registrations"]:
+                if registration["method"] == "workspace/executeCommand":
+                    self.initialize_searcher_command_available.set()
+                    self.resolve_main_method_available.set()
+            return
+
+        def lang_status_handler(params):
+            # TODO: Should we wait for
+            # server -> client: {'jsonrpc': '2.0', 'method': 'language/status', 'params': {'type': 'ProjectStatus', 'message': 'OK'}}
+            # Before proceeding?
+            if params["type"] == "ServiceReady" and params["message"] == "ServiceReady":
+                self.service_ready_event.set()
+
+        def execute_client_command_handler(params):
+            return []
+
+        def do_nothing(params):
+            return
+
+        def check_experimental_status(params):
+            if params["quiescent"] == True:
+                self.server_ready.set()
+
+        def window_log_message(msg):
+            self.logger.log(f"LSP: window/logMessage: {msg}", logging.INFO)
+
+        self.server.on_request("client/registerCapability", register_capability_handler)
+        self.server.on_notification("language/status", lang_status_handler)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_request("workspace/executeClientCommand", execute_client_command_handler)
+        self.server.on_notification("$/progress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+        self.server.on_notification("language/actionableNotification", do_nothing)
+        self.server.on_notification("experimental/serverStatus", check_experimental_status)
+
+        self.logger.log("Starting Clangd server process", logging.INFO)
+        self.server.start()
+        initialize_params = self._get_initialize_params(self.repository_root_path)
+
+        self.logger.log(
+            "Sending initialize request from LSP client to LSP server and awaiting response",
+            logging.INFO,
+        )
+        init_response = self.server.send.initialize(initialize_params)
+        assert init_response["capabilities"]["textDocumentSync"]["change"] == 2
+        assert "completionProvider" in init_response["capabilities"]
+        assert init_response["capabilities"]["completionProvider"] == {
+            "triggerCharacters": [".", "<", ">", ":", '"', "/", "*"],
+            "resolveProvider": False,
+        }
+
+        self.server.notify.initialized({})
+
+        self.completions_available.set()
+        # set ready flag
+        self.server_ready.set()
+        self.server_ready.wait()

projects/ui/serena-new/src/solidlsp/language_servers/clojure_lsp.py

@@ -0,0 +1,220 @@
+"""
+Provides Clojure specific instantiation of the LanguageServer class. Contains various configurations and settings specific to Clojure.
+"""
+
+import logging
+import os
+import pathlib
+import shutil
+import subprocess
+import threading
+
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.lsp_protocol_handler.lsp_types import InitializeParams
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+from .common import RuntimeDependency, RuntimeDependencyCollection
+
+
+def run_command(cmd: list, capture_output: bool = True) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        cmd, stdout=subprocess.PIPE if capture_output else None, stderr=subprocess.STDOUT if capture_output else None, text=True, check=True
+    )
+
+
+def verify_clojure_cli():
+    install_msg = "Please install the official Clojure CLI from:\n  https://clojure.org/guides/getting_started"
+    if shutil.which("clojure") is None:
+        raise FileNotFoundError("`clojure` not found.\n" + install_msg)
+
+    help_proc = run_command(["clojure", "--help"])
+    if "-Aaliases" not in help_proc.stdout:
+        raise RuntimeError("Detected a Clojure executable, but it does not support '-Aaliases'.\n" + install_msg)
+
+    spath_proc = run_command(["clojure", "-Spath"], capture_output=False)
+    if spath_proc.returncode != 0:
+        raise RuntimeError("`clojure -Spath` failed; please upgrade to Clojure CLI ≥ 1.10.")
+
+
+class ClojureLSP(SolidLanguageServer):
+    """
+    Provides a clojure-lsp specific instantiation of the LanguageServer class. Contains various configurations and settings specific to clojure.
+    """
+
+    clojure_lsp_releases = "https://github.com/clojure-lsp/clojure-lsp/releases/latest/download"
+    runtime_dependencies = RuntimeDependencyCollection(
+        [
+            RuntimeDependency(
+                id="clojure-lsp",
+                url=f"{clojure_lsp_releases}/clojure-lsp-native-macos-aarch64.zip",
+                platform_id="osx-arm64",
+                archive_type="zip",
+                binary_name="clojure-lsp",
+            ),
+            RuntimeDependency(
+                id="clojure-lsp",
+                url=f"{clojure_lsp_releases}/clojure-lsp-native-macos-amd64.zip",
+                platform_id="osx-x64",
+                archive_type="zip",
+                binary_name="clojure-lsp",
+            ),
+            RuntimeDependency(
+                id="clojure-lsp",
+                url=f"{clojure_lsp_releases}/clojure-lsp-native-linux-aarch64.zip",
+                platform_id="linux-arm64",
+                archive_type="zip",
+                binary_name="clojure-lsp",
+            ),
+            RuntimeDependency(
+                id="clojure-lsp",
+                url=f"{clojure_lsp_releases}/clojure-lsp-native-linux-amd64.zip",
+                platform_id="linux-x64",
+                archive_type="zip",
+                binary_name="clojure-lsp",
+            ),
+            RuntimeDependency(
+                id="clojure-lsp",
+                url=f"{clojure_lsp_releases}/clojure-lsp-native-windows-amd64.zip",
+                platform_id="win-x64",
+                archive_type="zip",
+                binary_name="clojure-lsp.exe",
+            ),
+        ]
+    )
+
+    def __init__(
+        self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str, solidlsp_settings: SolidLSPSettings
+    ):
+        """
+        Creates a ClojureLSP instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
+        """
+        clojure_lsp_executable_path = self._setup_runtime_dependencies(logger, config, solidlsp_settings)
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=clojure_lsp_executable_path, cwd=repository_root_path),
+            "clojure",
+            solidlsp_settings,
+        )
+        self.server_ready = threading.Event()
+        self.initialize_searcher_command_available = threading.Event()
+        self.resolve_main_method_available = threading.Event()
+        self.service_ready_event = threading.Event()
+
+    @classmethod
+    def _setup_runtime_dependencies(
+        cls, logger: LanguageServerLogger, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings
+    ) -> str:
+        """Setup runtime dependencies for clojure-lsp and return the command to start the server."""
+        verify_clojure_cli()
+        deps = ClojureLSP.runtime_dependencies
+        dependency = deps.single_for_current_platform()
+
+        clojurelsp_ls_dir = cls.ls_resources_dir(solidlsp_settings)
+        clojurelsp_executable_path = deps.binary_path(clojurelsp_ls_dir)
+        if not os.path.exists(clojurelsp_executable_path):
+            logger.log(
+                f"Downloading and extracting clojure-lsp from {dependency.url} to {clojurelsp_ls_dir}",
+                logging.INFO,
+            )
+            deps.install(logger, clojurelsp_ls_dir)
+        if not os.path.exists(clojurelsp_executable_path):
+            raise FileNotFoundError(f"Download failed? Could not find clojure-lsp executable at {clojurelsp_executable_path}")
+        os.chmod(clojurelsp_executable_path, 0o755)
+        return clojurelsp_executable_path
+
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
+        """Returns the init params for clojure-lsp."""
+        root_uri = pathlib.Path(repository_absolute_path).as_uri()
+        return {  # type: ignore
+            "processId": os.getpid(),
+            "rootPath": repository_absolute_path,
+            "rootUri": root_uri,
+            "capabilities": {
+                "workspace": {
+                    "applyEdit": True,
+                    "workspaceEdit": {"documentChanges": True},
+                    "symbol": {"symbolKind": {"valueSet": list(range(1, 27))}},
+                    "workspaceFolders": True,
+                },
+                "textDocument": {
+                    "synchronization": {"didSave": True},
+                    "publishDiagnostics": {"relatedInformation": True, "tagSupport": {"valueSet": [1, 2]}},
+                    "definition": {"linkSupport": True},
+                    "references": {},
+                    "hover": {"contentFormat": ["markdown", "plaintext"]},
+                    "documentSymbol": {
+                        "hierarchicalDocumentSymbolSupport": True,
+                        "symbolKind": {"valueSet": list(range(1, 27))},  #
+                    },
+                },
+                "general": {"positionEncodings": ["utf-16"]},
+            },
+            "initializationOptions": {"dependency-scheme": "jar", "text-document-sync-kind": "incremental"},
+            "trace": "off",
+            "workspaceFolders": [{"uri": root_uri, "name": os.path.basename(repository_absolute_path)}],
+        }
+
+    def _start_server(self):
+        def register_capability_handler(params):
+            assert "registrations" in params
+            for registration in params["registrations"]:
+                if registration["method"] == "workspace/executeCommand":
+                    self.initialize_searcher_command_available.set()
+                    self.resolve_main_method_available.set()
+            return
+
+        def lang_status_handler(params):
+            # TODO: Should we wait for
+            # server -> client: {'jsonrpc': '2.0', 'method': 'language/status', 'params': {'type': 'ProjectStatus', 'message': 'OK'}}
+            # Before proceeding?
+            if params["type"] == "ServiceReady" and params["message"] == "ServiceReady":
+                self.service_ready_event.set()
+
+        def execute_client_command_handler(params):
+            return []
+
+        def do_nothing(params):
+            return
+
+        def check_experimental_status(params):
+            if params["quiescent"] == True:
+                self.server_ready.set()
+
+        def window_log_message(msg):
+            self.logger.log(f"LSP: window/logMessage: {msg}", logging.INFO)
+
+        self.server.on_request("client/registerCapability", register_capability_handler)
+        self.server.on_notification("language/status", lang_status_handler)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_request("workspace/executeClientCommand", execute_client_command_handler)
+        self.server.on_notification("$/progress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+        self.server.on_notification("language/actionableNotification", do_nothing)
+        self.server.on_notification("experimental/serverStatus", check_experimental_status)
+
+        self.logger.log("Starting clojure-lsp server process", logging.INFO)
+        self.server.start()
+
+        initialize_params = self._get_initialize_params(self.repository_root_path)
+
+        self.logger.log(
+            "Sending initialize request from LSP client to LSP server and awaiting response",
+            logging.INFO,
+        )
+        init_response = self.server.send.initialize(initialize_params)
+        assert init_response["capabilities"]["textDocumentSync"]["change"] == 2
+        assert "completionProvider" in init_response["capabilities"]
+        # Clojure-lsp completion provider capabilities are more flexible than other servers'
+        completion_provider = init_response["capabilities"]["completionProvider"]
+        assert completion_provider["resolveProvider"] == True
+        assert "triggerCharacters" in completion_provider
+        self.server.notify.initialized({})
+        # after initialize, Clojure-lsp is ready to serve
+        self.server_ready.set()
+        self.completions_available.set()

projects/ui/serena-new/src/solidlsp/language_servers/common.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import logging
+import os
+import platform
+import subprocess
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.ls_utils import FileUtils, PlatformUtils
+from solidlsp.util.subprocess_util import subprocess_kwargs
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(kw_only=True)
+class RuntimeDependency:
+    """Represents a runtime dependency for a language server."""
+
+    id: str
+    platform_id: str | None = None
+    url: str | None = None
+    archive_type: str | None = None
+    binary_name: str | None = None
+    command: str | list[str] | None = None
+    package_name: str | None = None
+    package_version: str | None = None
+    extract_path: str | None = None
+    description: str | None = None
+
+
+class RuntimeDependencyCollection:
+    """Utility to handle installation of runtime dependencies."""
+
+    def __init__(self, dependencies: Sequence[RuntimeDependency]):
+        self._dependencies = list(dependencies)
+
+    def for_platform(self, platform_id: str) -> list[RuntimeDependency]:
+        return [d for d in self._dependencies if d.platform_id in (platform_id, "any", "platform-agnostic", None)]
+
+    def for_current_platform(self) -> list[RuntimeDependency]:
+        return self.for_platform(PlatformUtils.get_platform_id().value)
+
+    def single_for_current_platform(self) -> RuntimeDependency:
+        deps = self.for_current_platform()
+        if len(deps) != 1:
+            raise RuntimeError(f"Expected exactly one runtime dependency for {PlatformUtils.get_platform_id().value}, found {len(deps)}")
+        return deps[0]
+
+    def binary_path(self, target_dir: str) -> str:
+        dep = self.single_for_current_platform()
+        if not dep.binary_name:
+            return target_dir
+        return os.path.join(target_dir, dep.binary_name)
+
+    def install(self, logger: LanguageServerLogger, target_dir: str) -> dict[str, str]:
+        """Install all dependencies for the current platform into *target_dir*.
+
+        Returns a mapping from dependency id to the resolved binary path.
+        """
+        os.makedirs(target_dir, exist_ok=True)
+        results: dict[str, str] = {}
+        for dep in self.for_current_platform():
+            if dep.url:
+                self._install_from_url(dep, logger, target_dir)
+            if dep.command:
+                self._run_command(dep.command, target_dir)
+            if dep.binary_name:
+                results[dep.id] = os.path.join(target_dir, dep.binary_name)
+            else:
+                results[dep.id] = target_dir
+        return results
+
+    @staticmethod
+    def _run_command(command: str | list[str], cwd: str) -> None:
+        kwargs = subprocess_kwargs()
+        if not PlatformUtils.get_platform_id().is_windows():
+            import pwd
+
+            kwargs["user"] = pwd.getpwuid(os.getuid()).pw_name
+
+        is_windows = platform.system() == "Windows"
+        if not isinstance(command, 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
+            command = " ".join(command)
+
+        log.info("Running command %s in '%s'", f"'{command}'" if isinstance(command, str) else command, cwd)
+
+        completed_process = subprocess.run(
+            command,
+            shell=True,
+            check=True,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            **kwargs,
+        )
+        if completed_process.returncode != 0:
+            log.warning("Command '%s' failed with return code %d", command, completed_process.returncode)
+            log.warning("Command output:\n%s", completed_process.stdout)
+        else:
+            log.info(
+                "Command completed successfully",
+            )
+
+    @staticmethod
+    def _install_from_url(dep: RuntimeDependency, logger: LanguageServerLogger, target_dir: str) -> None:
+        if dep.archive_type == "gz" and dep.binary_name:
+            dest = os.path.join(target_dir, dep.binary_name)
+            FileUtils.download_and_extract_archive(logger, dep.url, dest, dep.archive_type)
+        else:
+            FileUtils.download_and_extract_archive(logger, dep.url, target_dir, dep.archive_type or "zip")

projects/ui/serena-new/src/solidlsp/language_servers/csharp_language_server.py

@@ -0,0 +1,741 @@
+"""
+CSharp Language Server using Microsoft.CodeAnalysis.LanguageServer (Official Roslyn-based LSP server)
+"""
+
+import json
+import logging
+import os
+import platform
+import shutil
+import subprocess
+import tarfile
+import threading
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import cast
+
+from overrides import override
+
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_exceptions import SolidLSPException
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.ls_utils import PathUtils
+from solidlsp.lsp_protocol_handler.lsp_types import InitializeParams
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+from solidlsp.util.zip import SafeZipExtractor
+
+from .common import RuntimeDependency
+
+# Runtime dependencies configuration
+RUNTIME_DEPENDENCIES = [
+    RuntimeDependency(
+        id="CSharpLanguageServer",
+        description="Microsoft.CodeAnalysis.LanguageServer for Windows (x64)",
+        package_name="Microsoft.CodeAnalysis.LanguageServer.win-x64",
+        package_version="5.0.0-1.25329.6",
+        platform_id="win-x64",
+        archive_type="nupkg",
+        binary_name="Microsoft.CodeAnalysis.LanguageServer.dll",
+        extract_path="content/LanguageServer/win-x64",
+    ),
+    RuntimeDependency(
+        id="CSharpLanguageServer",
+        description="Microsoft.CodeAnalysis.LanguageServer for Windows (ARM64)",
+        package_name="Microsoft.CodeAnalysis.LanguageServer.win-arm64",
+        package_version="5.0.0-1.25329.6",
+        platform_id="win-arm64",
+        archive_type="nupkg",
+        binary_name="Microsoft.CodeAnalysis.LanguageServer.dll",
+        extract_path="content/LanguageServer/win-arm64",
+    ),
+    RuntimeDependency(
+        id="CSharpLanguageServer",
+        description="Microsoft.CodeAnalysis.LanguageServer for macOS (x64)",
+        package_name="Microsoft.CodeAnalysis.LanguageServer.osx-x64",
+        package_version="5.0.0-1.25329.6",
+        platform_id="osx-x64",
+        archive_type="nupkg",
+        binary_name="Microsoft.CodeAnalysis.LanguageServer.dll",
+        extract_path="content/LanguageServer/osx-x64",
+    ),
+    RuntimeDependency(
+        id="CSharpLanguageServer",
+        description="Microsoft.CodeAnalysis.LanguageServer for macOS (ARM64)",
+        package_name="Microsoft.CodeAnalysis.LanguageServer.osx-arm64",
+        package_version="5.0.0-1.25329.6",
+        platform_id="osx-arm64",
+        archive_type="nupkg",
+        binary_name="Microsoft.CodeAnalysis.LanguageServer.dll",
+        extract_path="content/LanguageServer/osx-arm64",
+    ),
+    RuntimeDependency(
+        id="CSharpLanguageServer",
+        description="Microsoft.CodeAnalysis.LanguageServer for Linux (x64)",
+        package_name="Microsoft.CodeAnalysis.LanguageServer.linux-x64",
+        package_version="5.0.0-1.25329.6",
+        platform_id="linux-x64",
+        archive_type="nupkg",
+        binary_name="Microsoft.CodeAnalysis.LanguageServer.dll",
+        extract_path="content/LanguageServer/linux-x64",
+    ),
+    RuntimeDependency(
+        id="CSharpLanguageServer",
+        description="Microsoft.CodeAnalysis.LanguageServer for Linux (ARM64)",
+        package_name="Microsoft.CodeAnalysis.LanguageServer.linux-arm64",
+        package_version="5.0.0-1.25329.6",
+        platform_id="linux-arm64",
+        archive_type="nupkg",
+        binary_name="Microsoft.CodeAnalysis.LanguageServer.dll",
+        extract_path="content/LanguageServer/linux-arm64",
+    ),
+    RuntimeDependency(
+        id="DotNetRuntime",
+        description=".NET 9 Runtime for Windows (x64)",
+        url="https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-win-x64.zip",
+        platform_id="win-x64",
+        archive_type="zip",
+        binary_name="dotnet.exe",
+    ),
+    RuntimeDependency(
+        id="DotNetRuntime",
+        description=".NET 9 Runtime for Linux (x64)",
+        url="https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-linux-x64.tar.gz",
+        platform_id="linux-x64",
+        archive_type="tar.gz",
+        binary_name="dotnet",
+    ),
+    RuntimeDependency(
+        id="DotNetRuntime",
+        description=".NET 9 Runtime for macOS (x64)",
+        url="https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-osx-x64.tar.gz",
+        platform_id="osx-x64",
+        archive_type="tar.gz",
+        binary_name="dotnet",
+    ),
+    RuntimeDependency(
+        id="DotNetRuntime",
+        description=".NET 9 Runtime for macOS (ARM64)",
+        url="https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-osx-arm64.tar.gz",
+        platform_id="osx-arm64",
+        archive_type="tar.gz",
+        binary_name="dotnet",
+    ),
+]
+
+
+def breadth_first_file_scan(root_dir):
+    """
+    Perform a breadth-first scan of files in the given directory.
+    Yields file paths in breadth-first order.
+    """
+    queue = [root_dir]
+    while queue:
+        current_dir = queue.pop(0)
+        try:
+            for item in os.listdir(current_dir):
+                if item.startswith("."):
+                    continue
+                item_path = os.path.join(current_dir, item)
+                if os.path.isdir(item_path):
+                    queue.append(item_path)
+                elif os.path.isfile(item_path):
+                    yield item_path
+        except (PermissionError, OSError):
+            # Skip directories we can't access
+            pass
+
+
+def find_solution_or_project_file(root_dir) -> str | None:
+    """
+    Find the first .sln file in breadth-first order.
+    If no .sln file is found, look for a .csproj file.
+    """
+    sln_file = None
+    csproj_file = None
+
+    for filename in breadth_first_file_scan(root_dir):
+        if filename.endswith(".sln") and sln_file is None:
+            sln_file = filename
+        elif filename.endswith(".csproj") and csproj_file is None:
+            csproj_file = filename
+
+        # If we found a .sln file, return it immediately
+        if sln_file:
+            return sln_file
+
+    # If no .sln file was found, return the first .csproj file
+    return csproj_file
+
+
+class CSharpLanguageServer(SolidLanguageServer):
+    """
+    Provides C# specific instantiation of the LanguageServer class using Microsoft.CodeAnalysis.LanguageServer.
+    This is the official Roslyn-based language server from Microsoft.
+    """
+
+    def __init__(
+        self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str, solidlsp_settings: SolidLSPSettings
+    ):
+        """
+        Creates a CSharpLanguageServer instance. This class is not meant to be instantiated directly.
+        Use LanguageServer.create() instead.
+        """
+        dotnet_path, language_server_path = self._ensure_server_installed(logger, config, solidlsp_settings)
+
+        # Find solution or project file
+        solution_or_project = find_solution_or_project_file(repository_root_path)
+
+        # Create log directory
+        log_dir = Path(self.ls_resources_dir(solidlsp_settings)) / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+
+        # Build command using dotnet directly
+        cmd = [dotnet_path, language_server_path, "--logLevel=Information", f"--extensionLogDirectory={log_dir}", "--stdio"]
+
+        # The language server will discover the solution/project from the workspace root
+        if solution_or_project:
+            logger.log(f"Found solution/project file: {solution_or_project}", logging.INFO)
+        else:
+            logger.log("No .sln or .csproj file found, language server will attempt auto-discovery", logging.WARNING)
+
+        logger.log(f"Language server command: {' '.join(cmd)}", logging.DEBUG)
+
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=cmd, cwd=repository_root_path),
+            "csharp",
+            solidlsp_settings,
+        )
+
+        self.initialization_complete = threading.Event()
+
+    @override
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        return super().is_ignored_dirname(dirname) or dirname in ["bin", "obj", "packages", ".vs"]
+
+    @classmethod
+    def _ensure_server_installed(
+        cls, logger: LanguageServerLogger, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings
+    ) -> tuple[str, str]:
+        """
+        Ensure .NET runtime and Microsoft.CodeAnalysis.LanguageServer are available.
+        Returns a tuple of (dotnet_path, language_server_dll_path).
+        """
+        runtime_id = CSharpLanguageServer._get_runtime_id()
+        lang_server_dep, dotnet_runtime_dep = CSharpLanguageServer._get_runtime_dependencies(runtime_id)
+        dotnet_path = CSharpLanguageServer._ensure_dotnet_runtime(logger, dotnet_runtime_dep, solidlsp_settings)
+        server_dll_path = CSharpLanguageServer._ensure_language_server(logger, lang_server_dep, solidlsp_settings)
+
+        return dotnet_path, server_dll_path
+
+    @staticmethod
+    def _get_runtime_id() -> str:
+        """Determine the runtime ID based on the platform."""
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+
+        if system == "windows":
+            return "win-x64" if machine in ["amd64", "x86_64"] else "win-arm64"
+        elif system == "darwin":
+            return "osx-x64" if machine in ["x86_64"] else "osx-arm64"
+        elif system == "linux":
+            return "linux-x64" if machine in ["x86_64", "amd64"] else "linux-arm64"
+        else:
+            raise SolidLSPException(f"Unsupported platform: {system} {machine}")
+
+    @staticmethod
+    def _get_runtime_dependencies(runtime_id: str) -> tuple[RuntimeDependency, RuntimeDependency]:
+        """Get the language server and .NET runtime dependencies for the platform."""
+        lang_server_dep = None
+        dotnet_runtime_dep = None
+
+        for dep in RUNTIME_DEPENDENCIES:
+            if dep.id == "CSharpLanguageServer" and dep.platform_id == runtime_id:
+                lang_server_dep = dep
+            elif dep.id == "DotNetRuntime" and dep.platform_id == runtime_id:
+                dotnet_runtime_dep = dep
+
+        if not lang_server_dep:
+            raise SolidLSPException(f"No C# language server dependency found for platform {runtime_id}")
+        if not dotnet_runtime_dep:
+            raise SolidLSPException(f"No .NET runtime dependency found for platform {runtime_id}")
+
+        return lang_server_dep, dotnet_runtime_dep
+
+    @classmethod
+    def _ensure_dotnet_runtime(
+        cls, logger: LanguageServerLogger, runtime_dep: RuntimeDependency, solidlsp_settings: SolidLSPSettings
+    ) -> str:
+        """Ensure .NET runtime is available and return the dotnet executable path."""
+        # Check if dotnet is already available on the system
+        system_dotnet = shutil.which("dotnet")
+        if system_dotnet:
+            # Check if it's .NET 9
+            try:
+                result = subprocess.run([system_dotnet, "--list-runtimes"], capture_output=True, text=True, check=True)
+                if "Microsoft.NETCore.App 9." in result.stdout:
+                    logger.log("Found system .NET 9 runtime", logging.INFO)
+                    return system_dotnet
+            except subprocess.CalledProcessError:
+                pass
+
+        # Download .NET 9 runtime using config
+        return cls._ensure_dotnet_runtime_from_config(logger, runtime_dep, solidlsp_settings)
+
+    @classmethod
+    def _ensure_language_server(
+        cls, logger: LanguageServerLogger, lang_server_dep: RuntimeDependency, solidlsp_settings: SolidLSPSettings
+    ) -> str:
+        """Ensure language server is available and return the DLL path."""
+        package_name = lang_server_dep.package_name
+        package_version = lang_server_dep.package_version
+
+        server_dir = Path(cls.ls_resources_dir(solidlsp_settings)) / f"{package_name}.{package_version}"
+        server_dll = server_dir / lang_server_dep.binary_name
+
+        if server_dll.exists():
+            logger.log(f"Using cached Microsoft.CodeAnalysis.LanguageServer from {server_dll}", logging.INFO)
+            return str(server_dll)
+
+        # Download and install the language server
+        logger.log(f"Downloading {package_name} version {package_version}...", logging.INFO)
+        package_path = cls._download_nuget_package_direct(logger, package_name, package_version, solidlsp_settings)
+
+        # Extract and install
+        cls._extract_language_server(lang_server_dep, package_path, server_dir)
+
+        if not server_dll.exists():
+            raise SolidLSPException("Microsoft.CodeAnalysis.LanguageServer.dll not found after extraction")
+
+        # Make executable on Unix systems
+        if platform.system().lower() != "windows":
+            server_dll.chmod(0o755)
+
+        logger.log(f"Successfully installed Microsoft.CodeAnalysis.LanguageServer to {server_dll}", logging.INFO)
+        return str(server_dll)
+
+    @staticmethod
+    def _extract_language_server(lang_server_dep: RuntimeDependency, package_path: Path, server_dir: Path) -> None:
+        """Extract language server files from downloaded package."""
+        extract_path = lang_server_dep.extract_path or "lib/net9.0"
+        source_dir = package_path / extract_path
+
+        if not source_dir.exists():
+            # Try alternative locations
+            for possible_dir in [
+                package_path / "tools" / "net9.0" / "any",
+                package_path / "lib" / "net9.0",
+                package_path / "contentFiles" / "any" / "net9.0",
+            ]:
+                if possible_dir.exists():
+                    source_dir = possible_dir
+                    break
+            else:
+                raise SolidLSPException(f"Could not find language server files in package. Searched in {package_path}")
+
+        # Copy files to cache directory
+        server_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(source_dir, server_dir, dirs_exist_ok=True)
+
+    @classmethod
+    def _download_nuget_package_direct(
+        cls, logger: LanguageServerLogger, package_name: str, package_version: str, solidlsp_settings: SolidLSPSettings
+    ) -> Path:
+        """
+        Download a NuGet package directly from the Azure NuGet feed.
+        Returns the path to the extracted package directory.
+        """
+        azure_feed_url = "https://pkgs.dev.azure.com/azure-public/vside/_packaging/vs-impl/nuget/v3/index.json"
+
+        # Create temporary directory for package download
+        temp_dir = Path(cls.ls_resources_dir(solidlsp_settings)) / "temp_downloads"
+        temp_dir.mkdir(parents=True, exist_ok=True)
+
+        try:
+            # First, get the service index from the Azure feed
+            logger.log("Fetching NuGet service index from Azure feed...", logging.DEBUG)
+            with urllib.request.urlopen(azure_feed_url) as response:
+                service_index = json.loads(response.read().decode())
+
+            # Find the package base address (for downloading packages)
+            package_base_address = None
+            for resource in service_index.get("resources", []):
+                if resource.get("@type") == "PackageBaseAddress/3.0.0":
+                    package_base_address = resource.get("@id")
+                    break
+
+            if not package_base_address:
+                raise SolidLSPException("Could not find package base address in Azure NuGet feed")
+
+            # Construct the download URL for the specific package
+            package_id_lower = package_name.lower()
+            package_version_lower = package_version.lower()
+            package_url = f"{package_base_address.rstrip('/')}/{package_id_lower}/{package_version_lower}/{package_id_lower}.{package_version_lower}.nupkg"
+
+            logger.log(f"Downloading package from: {package_url}", logging.DEBUG)
+
+            # Download the .nupkg file
+            nupkg_file = temp_dir / f"{package_name}.{package_version}.nupkg"
+            urllib.request.urlretrieve(package_url, nupkg_file)
+
+            # Extract the .nupkg file (it's just a zip file)
+            package_extract_dir = temp_dir / f"{package_name}.{package_version}"
+            package_extract_dir.mkdir(exist_ok=True)
+
+            # Use SafeZipExtractor to handle long paths and skip errors
+            extractor = SafeZipExtractor(archive_path=nupkg_file, extract_dir=package_extract_dir, verbose=False)
+            extractor.extract_all()
+
+            # Clean up the nupkg file
+            nupkg_file.unlink()
+
+            logger.log(f"Successfully downloaded and extracted {package_name} version {package_version}", logging.INFO)
+            return package_extract_dir
+
+        except Exception as e:
+            raise SolidLSPException(
+                f"Failed to download package {package_name} version {package_version} from Azure NuGet feed: {e}"
+            ) from e
+
+    @classmethod
+    def _ensure_dotnet_runtime_from_config(
+        cls, logger: LanguageServerLogger, runtime_dep: RuntimeDependency, solidlsp_settings: SolidLSPSettings
+    ) -> str:
+        """
+        Ensure .NET 9 runtime is available using runtime dependency configuration.
+        Returns the path to the dotnet executable.
+        """
+        # Check if dotnet is already available on the system
+        system_dotnet = shutil.which("dotnet")
+        if system_dotnet:
+            # Check if it's .NET 9
+            try:
+                result = subprocess.run([system_dotnet, "--list-runtimes"], capture_output=True, text=True, check=True)
+                if "Microsoft.NETCore.App 9." in result.stdout:
+                    logger.log("Found system .NET 9 runtime", logging.INFO)
+                    return system_dotnet
+            except subprocess.CalledProcessError:
+                pass
+
+        # Download .NET 9 runtime using config
+        dotnet_dir = Path(cls.ls_resources_dir(solidlsp_settings)) / "dotnet-runtime-9.0"
+        dotnet_exe = dotnet_dir / runtime_dep.binary_name
+
+        if dotnet_exe.exists():
+            logger.log(f"Using cached .NET runtime from {dotnet_exe}", logging.INFO)
+            return str(dotnet_exe)
+
+        # Download .NET runtime
+        logger.log("Downloading .NET 9 runtime...", logging.INFO)
+        dotnet_dir.mkdir(parents=True, exist_ok=True)
+
+        url = runtime_dep.url
+        archive_type = runtime_dep.archive_type
+
+        # Download the runtime
+        download_path = dotnet_dir / f"dotnet-runtime.{archive_type}"
+        try:
+            logger.log(f"Downloading from {url}", logging.DEBUG)
+            urllib.request.urlretrieve(url, download_path)
+
+            # Extract the archive
+            if archive_type == "zip":
+                with zipfile.ZipFile(download_path, "r") as zip_ref:
+                    zip_ref.extractall(dotnet_dir)
+            else:
+                # tar.gz
+                with tarfile.open(download_path, "r:gz") as tar_ref:
+                    tar_ref.extractall(dotnet_dir)
+
+            # Remove the archive
+            download_path.unlink()
+
+            # Make dotnet executable on Unix
+            if platform.system().lower() != "windows":
+                dotnet_exe.chmod(0o755)
+
+            logger.log(f"Successfully installed .NET 9 runtime to {dotnet_exe}", logging.INFO)
+            return str(dotnet_exe)
+
+        except Exception as e:
+            raise SolidLSPException(f"Failed to download .NET 9 runtime from {url}: {e}") from e
+
+    def _get_initialize_params(self) -> InitializeParams:
+        """
+        Returns the initialize params for the Microsoft.CodeAnalysis.LanguageServer.
+        """
+        root_uri = PathUtils.path_to_uri(self.repository_root_path)
+        root_name = os.path.basename(self.repository_root_path)
+        return cast(
+            InitializeParams,
+            {
+                "workspaceFolders": [{"uri": root_uri, "name": root_name}],
+                "processId": os.getpid(),
+                "rootPath": self.repository_root_path,
+                "rootUri": root_uri,
+                "capabilities": {
+                    "window": {
+                        "workDoneProgress": True,
+                        "showMessage": {"messageActionItem": {"additionalPropertiesSupport": True}},
+                        "showDocument": {"support": True},
+                    },
+                    "workspace": {
+                        "applyEdit": True,
+                        "workspaceEdit": {"documentChanges": True},
+                        "didChangeConfiguration": {"dynamicRegistration": True},
+                        "didChangeWatchedFiles": {"dynamicRegistration": True},
+                        "symbol": {
+                            "dynamicRegistration": True,
+                            "symbolKind": {"valueSet": list(range(1, 27))},
+                        },
+                        "executeCommand": {"dynamicRegistration": True},
+                        "configuration": True,
+                        "workspaceFolders": True,
+                        "workDoneProgress": True,
+                    },
+                    "textDocument": {
+                        "synchronization": {"dynamicRegistration": True, "willSave": True, "willSaveWaitUntil": True, "didSave": True},
+                        "hover": {"dynamicRegistration": True, "contentFormat": ["markdown", "plaintext"]},
+                        "signatureHelp": {
+                            "dynamicRegistration": True,
+                            "signatureInformation": {
+                                "documentationFormat": ["markdown", "plaintext"],
+                                "parameterInformation": {"labelOffsetSupport": True},
+                            },
+                        },
+                        "definition": {"dynamicRegistration": True},
+                        "references": {"dynamicRegistration": True},
+                        "documentSymbol": {
+                            "dynamicRegistration": True,
+                            "symbolKind": {"valueSet": list(range(1, 27))},
+                            "hierarchicalDocumentSymbolSupport": True,
+                        },
+                    },
+                },
+            },
+        )
+
+    def _start_server(self):
+        def do_nothing(params):
+            return
+
+        def window_log_message(msg):
+            """Log messages from the language server."""
+            message_text = msg.get("message", "")
+            level = msg.get("type", 4)  # Default to Log level
+
+            # Map LSP message types to Python logging levels
+            level_map = {1: logging.ERROR, 2: logging.WARNING, 3: logging.INFO, 4: logging.DEBUG}  # Error  # Warning  # Info  # Log
+
+            self.logger.log(f"LSP: {message_text}", level_map.get(level, logging.DEBUG))
+
+        def handle_progress(params):
+            """Handle progress notifications from the language server."""
+            token = params.get("token", "")
+            value = params.get("value", {})
+
+            # Log raw progress for debugging
+            self.logger.log(f"Progress notification received: {params}", logging.DEBUG)
+
+            # Handle different progress notification types
+            kind = value.get("kind")
+
+            if kind == "begin":
+                title = value.get("title", "Operation in progress")
+                message = value.get("message", "")
+                percentage = value.get("percentage")
+
+                if percentage is not None:
+                    self.logger.log(f"Progress [{token}]: {title} - {message} ({percentage}%)", logging.INFO)
+                else:
+                    self.logger.log(f"Progress [{token}]: {title} - {message}", logging.INFO)
+
+            elif kind == "report":
+                message = value.get("message", "")
+                percentage = value.get("percentage")
+
+                if percentage is not None:
+                    self.logger.log(f"Progress [{token}]: {message} ({percentage}%)", logging.INFO)
+                elif message:
+                    self.logger.log(f"Progress [{token}]: {message}", logging.INFO)
+
+            elif kind == "end":
+                message = value.get("message", "Operation completed")
+                self.logger.log(f"Progress [{token}]: {message}", logging.INFO)
+
+        def handle_workspace_configuration(params):
+            """Handle workspace/configuration requests from the server."""
+            items = params.get("items", [])
+            result = []
+
+            for item in items:
+                section = item.get("section", "")
+
+                # Provide default values based on the configuration section
+                if section.startswith(("dotnet", "csharp")):
+                    # Default configuration for C# settings
+                    if "enable" in section or "show" in section or "suppress" in section or "navigate" in section:
+                        # Boolean settings
+                        result.append(False)
+                    elif "scope" in section:
+                        # Scope settings - use appropriate enum values
+                        if "analyzer_diagnostics_scope" in section:
+                            result.append("openFiles")  # BackgroundAnalysisScope
+                        elif "compiler_diagnostics_scope" in section:
+                            result.append("openFiles")  # CompilerDiagnosticsScope
+                        else:
+                            result.append("openFiles")
+                    elif section == "dotnet_member_insertion_location":
+                        # ImplementTypeInsertionBehavior enum
+                        result.append("with_other_members_of_the_same_kind")
+                    elif section == "dotnet_property_generation_behavior":
+                        # ImplementTypePropertyGenerationBehavior enum
+                        result.append("prefer_throwing_properties")
+                    elif "location" in section or "behavior" in section:
+                        # Other enum settings - return null to avoid parsing errors
+                        result.append(None)
+                    else:
+                        # Default for other dotnet/csharp settings
+                        result.append(None)
+                elif section == "tab_width" or section == "indent_size":
+                    # Tab and indent settings
+                    result.append(4)
+                elif section == "insert_final_newline":
+                    # Editor settings
+                    result.append(True)
+                else:
+                    # Unknown configuration - return null
+                    result.append(None)
+
+            return result
+
+        def handle_work_done_progress_create(params):
+            """Handle work done progress create requests."""
+            # Just acknowledge the request
+            return
+
+        def handle_register_capability(params):
+            """Handle client/registerCapability requests."""
+            # Just acknowledge the request - we don't need to track these for now
+            return
+
+        def handle_project_needs_restore(params):
+            return
+
+        # Set up notification handlers
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_notification("$/progress", handle_progress)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+        self.server.on_request("workspace/configuration", handle_workspace_configuration)
+        self.server.on_request("window/workDoneProgress/create", handle_work_done_progress_create)
+        self.server.on_request("client/registerCapability", handle_register_capability)
+        self.server.on_request("workspace/_roslyn_projectNeedsRestore", handle_project_needs_restore)
+
+        self.logger.log("Starting Microsoft.CodeAnalysis.LanguageServer process", logging.INFO)
+
+        try:
+            self.server.start()
+        except Exception as e:
+            self.logger.log(f"Failed to start language server process: {e}", logging.ERROR)
+            raise SolidLSPException(f"Failed to start C# language server: {e}")
+
+        # Send initialization
+        initialize_params = self._get_initialize_params()
+
+        self.logger.log("Sending initialize request to language server", logging.INFO)
+        try:
+            init_response = self.server.send.initialize(initialize_params)
+            self.logger.log(f"Received initialize response: {init_response}", logging.DEBUG)
+        except Exception as e:
+            raise SolidLSPException(f"Failed to initialize C# language server for {self.repository_root_path}: {e}") from e
+
+        # Apply diagnostic capabilities
+        self._force_pull_diagnostics(init_response)
+
+        # Verify required capabilities
+        capabilities = init_response.get("capabilities", {})
+        required_capabilities = [
+            "textDocumentSync",
+            "definitionProvider",
+            "referencesProvider",
+            "documentSymbolProvider",
+        ]
+        missing = [cap for cap in required_capabilities if cap not in capabilities]
+        if missing:
+            raise RuntimeError(
+                f"Language server is missing required capabilities: {', '.join(missing)}. "
+                "Initialization failed. Please ensure the correct version of Microsoft.CodeAnalysis.LanguageServer is installed and the .NET runtime is working."
+            )
+
+        # Complete initialization
+        self.server.notify.initialized({})
+
+        # Open solution and project files
+        self._open_solution_and_projects()
+
+        self.initialization_complete.set()
+        self.completions_available.set()
+
+        self.logger.log(
+            "Microsoft.CodeAnalysis.LanguageServer initialized and ready\n"
+            "Waiting for language server to index project files...\n"
+            "This may take a while for large projects",
+            logging.INFO,
+        )
+
+    def _force_pull_diagnostics(self, init_response: dict) -> None:
+        """
+        Apply the diagnostic capabilities hack.
+        Forces the server to support pull diagnostics.
+        """
+        capabilities = init_response.get("capabilities", {})
+        diagnostic_provider = capabilities.get("diagnosticProvider", {})
+
+        # Add the diagnostic capabilities hack
+        if isinstance(diagnostic_provider, dict):
+            diagnostic_provider.update(
+                {
+                    "interFileDependencies": True,
+                    "workDoneProgress": True,
+                    "workspaceDiagnostics": True,
+                }
+            )
+            self.logger.log("Applied diagnostic capabilities hack for better C# diagnostics", logging.DEBUG)
+
+    def _open_solution_and_projects(self) -> None:
+        """
+        Open solution and project files using notifications.
+        """
+        # Find solution file
+        solution_file = None
+        for filename in breadth_first_file_scan(self.repository_root_path):
+            if filename.endswith(".sln"):
+                solution_file = filename
+                break
+
+        # Send solution/open notification if solution file found
+        if solution_file:
+            solution_uri = PathUtils.path_to_uri(solution_file)
+            self.server.notify.send_notification("solution/open", {"solution": solution_uri})
+            self.logger.log(f"Opened solution file: {solution_file}", logging.INFO)
+
+        # Find and open project files
+        project_files = []
+        for filename in breadth_first_file_scan(self.repository_root_path):
+            if filename.endswith(".csproj"):
+                project_files.append(filename)
+
+        # Send project/open notifications for each project file
+        if project_files:
+            project_uris = [PathUtils.path_to_uri(project_file) for project_file in project_files]
+            self.server.notify.send_notification("project/open", {"projects": project_uris})
+            self.logger.log(f"Opened project files: {project_files}", logging.DEBUG)
+
+    @override
+    def _get_wait_time_for_cross_file_referencing(self) -> float:
+        return 2

projects/ui/serena-new/src/solidlsp/language_servers/dart_language_server.py

@@ -0,0 +1,158 @@
+import logging
+import os
+import pathlib
+
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+from .common import RuntimeDependency, RuntimeDependencyCollection
+
+
+class DartLanguageServer(SolidLanguageServer):
+    """
+    Provides Dart specific instantiation of the LanguageServer class. Contains various configurations and settings specific to Dart.
+    """
+
+    def __init__(self, config, logger, repository_root_path, solidlsp_settings: SolidLSPSettings):
+        """
+        Creates a DartServer instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
+        """
+        executable_path = self._setup_runtime_dependencies(logger, solidlsp_settings)
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=executable_path, cwd=repository_root_path),
+            "dart",
+            solidlsp_settings,
+        )
+
+    @classmethod
+    def _setup_runtime_dependencies(cls, logger: "LanguageServerLogger", solidlsp_settings: SolidLSPSettings) -> str:
+        deps = RuntimeDependencyCollection(
+            [
+                RuntimeDependency(
+                    id="DartLanguageServer",
+                    description="Dart Language Server for Linux (x64)",
+                    url="https://storage.googleapis.com/dart-archive/channels/stable/release/3.7.1/sdk/dartsdk-linux-x64-release.zip",
+                    platform_id="linux-x64",
+                    archive_type="zip",
+                    binary_name="dart-sdk/bin/dart",
+                ),
+                RuntimeDependency(
+                    id="DartLanguageServer",
+                    description="Dart Language Server for Windows (x64)",
+                    url="https://storage.googleapis.com/dart-archive/channels/stable/release/3.7.1/sdk/dartsdk-windows-x64-release.zip",
+                    platform_id="win-x64",
+                    archive_type="zip",
+                    binary_name="dart-sdk/bin/dart.exe",
+                ),
+                RuntimeDependency(
+                    id="DartLanguageServer",
+                    description="Dart Language Server for Windows (arm64)",
+                    url="https://storage.googleapis.com/dart-archive/channels/stable/release/3.7.1/sdk/dartsdk-windows-arm64-release.zip",
+                    platform_id="win-arm64",
+                    archive_type="zip",
+                    binary_name="dart-sdk/bin/dart.exe",
+                ),
+                RuntimeDependency(
+                    id="DartLanguageServer",
+                    description="Dart Language Server for macOS (x64)",
+                    url="https://storage.googleapis.com/dart-archive/channels/stable/release/3.7.1/sdk/dartsdk-macos-x64-release.zip",
+                    platform_id="osx-x64",
+                    archive_type="zip",
+                    binary_name="dart-sdk/bin/dart",
+                ),
+                RuntimeDependency(
+                    id="DartLanguageServer",
+                    description="Dart Language Server for macOS (arm64)",
+                    url="https://storage.googleapis.com/dart-archive/channels/stable/release/3.7.1/sdk/dartsdk-macos-arm64-release.zip",
+                    platform_id="osx-arm64",
+                    archive_type="zip",
+                    binary_name="dart-sdk/bin/dart",
+                ),
+            ]
+        )
+
+        dart_ls_dir = cls.ls_resources_dir(solidlsp_settings)
+        dart_executable_path = deps.binary_path(dart_ls_dir)
+
+        if not os.path.exists(dart_executable_path):
+            deps.install(logger, dart_ls_dir)
+
+        assert os.path.exists(dart_executable_path)
+        os.chmod(dart_executable_path, 0o755)
+
+        return f"{dart_executable_path} language-server --client-id multilspy.dart --client-version 1.2"
+
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str):
+        """
+        Returns the initialize params for the Dart Language Server.
+        """
+        root_uri = pathlib.Path(repository_absolute_path).as_uri()
+        initialize_params = {
+            "capabilities": {},
+            "initializationOptions": {
+                "onlyAnalyzeProjectsWithOpenFiles": False,
+                "closingLabels": False,
+                "outline": False,
+                "flutterOutline": False,
+                "allowOpenUri": False,
+            },
+            "trace": "verbose",
+            "processId": os.getpid(),
+            "rootPath": repository_absolute_path,
+            "rootUri": pathlib.Path(repository_absolute_path).as_uri(),
+            "workspaceFolders": [
+                {
+                    "uri": root_uri,
+                    "name": os.path.basename(repository_absolute_path),
+                }
+            ],
+        }
+
+        return initialize_params
+
+    def _start_server(self):
+        """
+        Start the language server and yield when the server is ready.
+        """
+
+        def execute_client_command_handler(params):
+            return []
+
+        def do_nothing(params):
+            return
+
+        def check_experimental_status(params):
+            pass
+
+        def window_log_message(msg):
+            self.logger.log(f"LSP: window/logMessage: {msg}", logging.INFO)
+
+        self.server.on_request("client/registerCapability", do_nothing)
+        self.server.on_notification("language/status", do_nothing)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_request("workspace/executeClientCommand", execute_client_command_handler)
+        self.server.on_notification("$/progress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+        self.server.on_notification("language/actionableNotification", do_nothing)
+        self.server.on_notification("experimental/serverStatus", check_experimental_status)
+
+        self.logger.log("Starting dart-language-server server process", logging.INFO)
+        self.server.start()
+        initialize_params = self._get_initialize_params(self.repository_root_path)
+        self.logger.log(
+            "Sending initialize request to dart-language-server",
+            logging.DEBUG,
+        )
+        init_response = self.server.send_request("initialize", initialize_params)
+        self.logger.log(
+            f"Received initialize response from dart-language-server: {init_response}",
+            logging.INFO,
+        )
+
+        self.server.notify.initialized({})

projects/ui/serena-new/src/solidlsp/language_servers/eclipse_jdtls.py

@@ -0,0 +1,723 @@
+"""
+Provides Java specific instantiation of the LanguageServer class. Contains various configurations and settings specific to Java.
+"""
+
+import dataclasses
+import logging
+import os
+import pathlib
+import shutil
+import threading
+import uuid
+from pathlib import PurePath
+
+from overrides import override
+
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.ls_utils import FileUtils, PlatformUtils
+from solidlsp.lsp_protocol_handler.lsp_types import InitializeParams
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+
+@dataclasses.dataclass
+class RuntimeDependencyPaths:
+    """
+    Stores the paths to the runtime dependencies of EclipseJDTLS
+    """
+
+    gradle_path: str
+    lombok_jar_path: str
+    jre_path: str
+    jre_home_path: str
+    jdtls_launcher_jar_path: str
+    jdtls_readonly_config_path: str
+    intellicode_jar_path: str
+    intellisense_members_path: str
+
+
+class EclipseJDTLS(SolidLanguageServer):
+    """
+    The EclipseJDTLS class provides a Java specific implementation of the LanguageServer class
+    """
+
+    def __init__(
+        self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str, solidlsp_settings: SolidLSPSettings
+    ):
+        """
+        Creates a new EclipseJDTLS instance initializing the language server settings appropriately.
+        This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
+        """
+        runtime_dependency_paths = self._setupRuntimeDependencies(logger, config, solidlsp_settings)
+        self.runtime_dependency_paths = runtime_dependency_paths
+
+        # ws_dir is the workspace directory for the EclipseJDTLS server
+        ws_dir = str(
+            PurePath(
+                solidlsp_settings.ls_resources_dir,
+                "EclipseJDTLS",
+                "workspaces",
+                uuid.uuid4().hex,
+            )
+        )
+
+        # shared_cache_location is the global cache used by Eclipse JDTLS across all workspaces
+        shared_cache_location = str(PurePath(solidlsp_settings.ls_resources_dir, "lsp", "EclipseJDTLS", "sharedIndex"))
+        os.makedirs(shared_cache_location, exist_ok=True)
+        os.makedirs(ws_dir, exist_ok=True)
+
+        jre_path = self.runtime_dependency_paths.jre_path
+        lombok_jar_path = self.runtime_dependency_paths.lombok_jar_path
+
+        jdtls_launcher_jar = self.runtime_dependency_paths.jdtls_launcher_jar_path
+
+        data_dir = str(PurePath(ws_dir, "data_dir"))
+        jdtls_config_path = str(PurePath(ws_dir, "config_path"))
+
+        jdtls_readonly_config_path = self.runtime_dependency_paths.jdtls_readonly_config_path
+
+        if not os.path.exists(jdtls_config_path):
+            shutil.copytree(jdtls_readonly_config_path, jdtls_config_path)
+
+        for static_path in [
+            jre_path,
+            lombok_jar_path,
+            jdtls_launcher_jar,
+            jdtls_config_path,
+            jdtls_readonly_config_path,
+        ]:
+            assert os.path.exists(static_path), static_path
+
+        # TODO: Add "self.runtime_dependency_paths.jre_home_path"/bin to $PATH as well
+        proc_env = {"syntaxserver": "false", "JAVA_HOME": self.runtime_dependency_paths.jre_home_path}
+        proc_cwd = repository_root_path
+        cmd = " ".join(
+            [
+                jre_path,
+                "--add-modules=ALL-SYSTEM",
+                "--add-opens",
+                "java.base/java.util=ALL-UNNAMED",
+                "--add-opens",
+                "java.base/java.lang=ALL-UNNAMED",
+                "--add-opens",
+                "java.base/sun.nio.fs=ALL-UNNAMED",
+                "-Declipse.application=org.eclipse.jdt.ls.core.id1",
+                "-Dosgi.bundles.defaultStartLevel=4",
+                "-Declipse.product=org.eclipse.jdt.ls.core.product",
+                "-Djava.import.generatesMetadataFilesAtProjectRoot=false",
+                "-Dfile.encoding=utf8",
+                "-noverify",
+                "-XX:+UseParallelGC",
+                "-XX:GCTimeRatio=4",
+                "-XX:AdaptiveSizePolicyWeight=90",
+                "-Dsun.zip.disableMemoryMapping=true",
+                "-Djava.lsp.joinOnCompletion=true",
+                "-Xmx3G",
+                "-Xms100m",
+                "-Xlog:disable",
+                "-Dlog.level=ALL",
+                f'"-javaagent:{lombok_jar_path}"',
+                f'"-Djdt.core.sharedIndexLocation={shared_cache_location}"',
+                "-jar",
+                f'"{jdtls_launcher_jar}"',
+                "-configuration",
+                f'"{jdtls_config_path}"',
+                "-data",
+                f'"{data_dir}"',
+            ]
+        )
+
+        self.service_ready_event = threading.Event()
+        self.intellicode_enable_command_available = threading.Event()
+        self.initialize_searcher_command_available = threading.Event()
+
+        super().__init__(
+            config, logger, repository_root_path, ProcessLaunchInfo(cmd, proc_env, proc_cwd), "java", solidlsp_settings=solidlsp_settings
+        )
+
+    @override
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        # Ignore common Java build directories from different build tools:
+        # - Maven: target
+        # - Gradle: build, .gradle
+        # - Eclipse: bin, .settings
+        # - IntelliJ IDEA: out, .idea
+        # - General: classes, dist, lib
+        return super().is_ignored_dirname(dirname) or dirname in [
+            "target",  # Maven
+            "build",  # Gradle
+            "bin",  # Eclipse
+            "out",  # IntelliJ IDEA
+            "classes",  # General
+            "dist",  # General
+            "lib",  # General
+        ]
+
+    @classmethod
+    def _setupRuntimeDependencies(
+        cls, logger: LanguageServerLogger, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings
+    ) -> RuntimeDependencyPaths:
+        """
+        Setup runtime dependencies for EclipseJDTLS and return the paths.
+        """
+        platformId = PlatformUtils.get_platform_id()
+
+        runtime_dependencies = {
+            "gradle": {
+                "platform-agnostic": {
+                    "url": "https://services.gradle.org/distributions/gradle-8.14.2-bin.zip",
+                    "archiveType": "zip",
+                    "relative_extraction_path": ".",
+                }
+            },
+            "vscode-java": {
+                "darwin-arm64": {
+                    "url": "https://github.com/redhat-developer/vscode-java/releases/download/v1.42.0/java-darwin-arm64-1.42.0-561.vsix",
+                    "archiveType": "zip",
+                    "relative_extraction_path": "vscode-java",
+                },
+                "osx-arm64": {
+                    "url": "https://github.com/redhat-developer/vscode-java/releases/download/v1.42.0/java-darwin-arm64-1.42.0-561.vsix",
+                    "archiveType": "zip",
+                    "relative_extraction_path": "vscode-java",
+                    "jre_home_path": "extension/jre/21.0.7-macosx-aarch64",
+                    "jre_path": "extension/jre/21.0.7-macosx-aarch64/bin/java",
+                    "lombok_jar_path": "extension/lombok/lombok-1.18.36.jar",
+                    "jdtls_launcher_jar_path": "extension/server/plugins/org.eclipse.equinox.launcher_1.7.0.v20250424-1814.jar",
+                    "jdtls_readonly_config_path": "extension/server/config_mac_arm",
+                },
+                "osx-x64": {
+                    "url": "https://github.com/redhat-developer/vscode-java/releases/download/v1.42.0/java-darwin-x64-1.42.0-561.vsix",
+                    "archiveType": "zip",
+                    "relative_extraction_path": "vscode-java",
+                    "jre_home_path": "extension/jre/21.0.7-macosx-x86_64",
+                    "jre_path": "extension/jre/21.0.7-macosx-x86_64/bin/java",
+                    "lombok_jar_path": "extension/lombok/lombok-1.18.36.jar",
+                    "jdtls_launcher_jar_path": "extension/server/plugins/org.eclipse.equinox.launcher_1.7.0.v20250424-1814.jar",
+                    "jdtls_readonly_config_path": "extension/server/config_mac",
+                },
+                "linux-arm64": {
+                    "url": "https://github.com/redhat-developer/vscode-java/releases/download/v1.42.0/java-linux-arm64-1.42.0-561.vsix",
+                    "archiveType": "zip",
+                    "relative_extraction_path": "vscode-java",
+                },
+                "linux-x64": {
+                    "url": "https://github.com/redhat-developer/vscode-java/releases/download/v1.42.0/java-linux-x64-1.42.0-561.vsix",
+                    "archiveType": "zip",
+                    "relative_extraction_path": "vscode-java",
+                    "jre_home_path": "extension/jre/21.0.7-linux-x86_64",
+                    "jre_path": "extension/jre/21.0.7-linux-x86_64/bin/java",
+                    "lombok_jar_path": "extension/lombok/lombok-1.18.36.jar",
+                    "jdtls_launcher_jar_path": "extension/server/plugins/org.eclipse.equinox.launcher_1.7.0.v20250424-1814.jar",
+                    "jdtls_readonly_config_path": "extension/server/config_linux",
+                },
+                "win-x64": {
+                    "url": "https://github.com/redhat-developer/vscode-java/releases/download/v1.42.0/java-win32-x64-1.42.0-561.vsix",
+                    "archiveType": "zip",
+                    "relative_extraction_path": "vscode-java",
+                    "jre_home_path": "extension/jre/21.0.7-win32-x86_64",
+                    "jre_path": "extension/jre/21.0.7-win32-x86_64/bin/java.exe",
+                    "lombok_jar_path": "extension/lombok/lombok-1.18.36.jar",
+                    "jdtls_launcher_jar_path": "extension/server/plugins/org.eclipse.equinox.launcher_1.7.0.v20250424-1814.jar",
+                    "jdtls_readonly_config_path": "extension/server/config_win",
+                },
+            },
+            "intellicode": {
+                "platform-agnostic": {
+                    "url": "https://VisualStudioExptTeam.gallery.vsassets.io/_apis/public/gallery/publisher/VisualStudioExptTeam/extension/vscodeintellicode/1.2.30/assetbyname/Microsoft.VisualStudio.Services.VSIXPackage",
+                    "alternate_url": "https://marketplace.visualstudio.com/_apis/public/gallery/publishers/VisualStudioExptTeam/vsextensions/vscodeintellicode/1.2.30/vspackage",
+                    "archiveType": "zip",
+                    "relative_extraction_path": "intellicode",
+                    "intellicode_jar_path": "extension/dist/com.microsoft.jdtls.intellicode.core-0.7.0.jar",
+                    "intellisense_members_path": "extension/dist/bundledModels/java_intellisense-members",
+                }
+            },
+        }
+
+        # assert platformId.value in [
+        #     "linux-x64",
+        #     "win-x64",
+        # ], "Only linux-x64 platform is supported for in multilspy at the moment"
+
+        gradle_path = str(
+            PurePath(
+                cls.ls_resources_dir(solidlsp_settings),
+                "gradle-8.14.2",
+            )
+        )
+
+        if not os.path.exists(gradle_path):
+            FileUtils.download_and_extract_archive(
+                logger,
+                runtime_dependencies["gradle"]["platform-agnostic"]["url"],
+                str(PurePath(gradle_path).parent),
+                runtime_dependencies["gradle"]["platform-agnostic"]["archiveType"],
+            )
+
+        assert os.path.exists(gradle_path)
+
+        dependency = runtime_dependencies["vscode-java"][platformId.value]
+        vscode_java_path = str(PurePath(cls.ls_resources_dir(solidlsp_settings), dependency["relative_extraction_path"]))
+        os.makedirs(vscode_java_path, exist_ok=True)
+        jre_home_path = str(PurePath(vscode_java_path, dependency["jre_home_path"]))
+        jre_path = str(PurePath(vscode_java_path, dependency["jre_path"]))
+        lombok_jar_path = str(PurePath(vscode_java_path, dependency["lombok_jar_path"]))
+        jdtls_launcher_jar_path = str(PurePath(vscode_java_path, dependency["jdtls_launcher_jar_path"]))
+        jdtls_readonly_config_path = str(PurePath(vscode_java_path, dependency["jdtls_readonly_config_path"]))
+        if not all(
+            [
+                os.path.exists(vscode_java_path),
+                os.path.exists(jre_home_path),
+                os.path.exists(jre_path),
+                os.path.exists(lombok_jar_path),
+                os.path.exists(jdtls_launcher_jar_path),
+                os.path.exists(jdtls_readonly_config_path),
+            ]
+        ):
+            FileUtils.download_and_extract_archive(logger, dependency["url"], vscode_java_path, dependency["archiveType"])
+
+        os.chmod(jre_path, 0o755)
+
+        assert os.path.exists(vscode_java_path)
+        assert os.path.exists(jre_home_path)
+        assert os.path.exists(jre_path)
+        assert os.path.exists(lombok_jar_path)
+        assert os.path.exists(jdtls_launcher_jar_path)
+        assert os.path.exists(jdtls_readonly_config_path)
+
+        dependency = runtime_dependencies["intellicode"]["platform-agnostic"]
+        intellicode_directory_path = str(PurePath(cls.ls_resources_dir(solidlsp_settings), dependency["relative_extraction_path"]))
+        os.makedirs(intellicode_directory_path, exist_ok=True)
+        intellicode_jar_path = str(PurePath(intellicode_directory_path, dependency["intellicode_jar_path"]))
+        intellisense_members_path = str(PurePath(intellicode_directory_path, dependency["intellisense_members_path"]))
+        if not all(
+            [
+                os.path.exists(intellicode_directory_path),
+                os.path.exists(intellicode_jar_path),
+                os.path.exists(intellisense_members_path),
+            ]
+        ):
+            FileUtils.download_and_extract_archive(logger, dependency["url"], intellicode_directory_path, dependency["archiveType"])
+
+        assert os.path.exists(intellicode_directory_path)
+        assert os.path.exists(intellicode_jar_path)
+        assert os.path.exists(intellisense_members_path)
+
+        return RuntimeDependencyPaths(
+            gradle_path=gradle_path,
+            lombok_jar_path=lombok_jar_path,
+            jre_path=jre_path,
+            jre_home_path=jre_home_path,
+            jdtls_launcher_jar_path=jdtls_launcher_jar_path,
+            jdtls_readonly_config_path=jdtls_readonly_config_path,
+            intellicode_jar_path=intellicode_jar_path,
+            intellisense_members_path=intellisense_members_path,
+        )
+
+    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+        """
+        Returns the initialize parameters for the EclipseJDTLS server.
+        """
+        # Look into https://github.com/eclipse/eclipse.jdt.ls/blob/master/org.eclipse.jdt.ls.core/src/org/eclipse/jdt/ls/core/internal/preferences/Preferences.java to understand all the options available
+
+        if not os.path.isabs(repository_absolute_path):
+            repository_absolute_path = os.path.abspath(repository_absolute_path)
+        repo_uri = pathlib.Path(repository_absolute_path).as_uri()
+
+        initialize_params = {
+            "locale": "en",
+            "rootPath": repository_absolute_path,
+            "rootUri": pathlib.Path(repository_absolute_path).as_uri(),
+            "capabilities": {
+                "workspace": {
+                    "applyEdit": True,
+                    "workspaceEdit": {
+                        "documentChanges": True,
+                        "resourceOperations": ["create", "rename", "delete"],
+                        "failureHandling": "textOnlyTransactional",
+                        "normalizesLineEndings": True,
+                        "changeAnnotationSupport": {"groupsOnLabel": True},
+                    },
+                    "didChangeConfiguration": {"dynamicRegistration": True},
+                    "didChangeWatchedFiles": {"dynamicRegistration": True, "relativePatternSupport": True},
+                    "symbol": {
+                        "dynamicRegistration": True,
+                        "symbolKind": {"valueSet": list(range(1, 27))},
+                        "tagSupport": {"valueSet": [1]},
+                        "resolveSupport": {"properties": ["location.range"]},
+                    },
+                    "codeLens": {"refreshSupport": True},
+                    "executeCommand": {"dynamicRegistration": True},
+                    "configuration": True,
+                    "workspaceFolders": True,
+                    "semanticTokens": {"refreshSupport": True},
+                    "fileOperations": {
+                        "dynamicRegistration": True,
+                        "didCreate": True,
+                        "didRename": True,
+                        "didDelete": True,
+                        "willCreate": True,
+                        "willRename": True,
+                        "willDelete": True,
+                    },
+                    "inlineValue": {"refreshSupport": True},
+                    "inlayHint": {"refreshSupport": True},
+                    "diagnostics": {"refreshSupport": True},
+                },
+                "textDocument": {
+                    "publishDiagnostics": {
+                        "relatedInformation": True,
+                        "versionSupport": False,
+                        "tagSupport": {"valueSet": [1, 2]},
+                        "codeDescriptionSupport": True,
+                        "dataSupport": True,
+                    },
+                    "synchronization": {"dynamicRegistration": True, "willSave": True, "willSaveWaitUntil": True, "didSave": True},
+                    # TODO: we have an assert that completion provider is not included in the capabilities at server startup
+                    #   Removing this will cause the assert to fail. Investigate why this is the case, simplify config
+                    "completion": {
+                        "dynamicRegistration": True,
+                        "contextSupport": True,
+                        "completionItem": {
+                            "snippetSupport": False,
+                            "commitCharactersSupport": True,
+                            "documentationFormat": ["markdown", "plaintext"],
+                            "deprecatedSupport": True,
+                            "preselectSupport": True,
+                            "tagSupport": {"valueSet": [1]},
+                            "insertReplaceSupport": False,
+                            "resolveSupport": {"properties": ["documentation", "detail", "additionalTextEdits"]},
+                            "insertTextModeSupport": {"valueSet": [1, 2]},
+                            "labelDetailsSupport": True,
+                        },
+                        "insertTextMode": 2,
+                        "completionItemKind": {
+                            "valueSet": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
+                        },
+                        "completionList": {"itemDefaults": ["commitCharacters", "editRange", "insertTextFormat", "insertTextMode"]},
+                    },
+                    "hover": {"dynamicRegistration": True, "contentFormat": ["markdown", "plaintext"]},
+                    "signatureHelp": {
+                        "dynamicRegistration": True,
+                        "signatureInformation": {
+                            "documentationFormat": ["markdown", "plaintext"],
+                            "parameterInformation": {"labelOffsetSupport": True},
+                            "activeParameterSupport": True,
+                        },
+                    },
+                    "definition": {"dynamicRegistration": True, "linkSupport": True},
+                    "references": {"dynamicRegistration": True},
+                    "documentSymbol": {
+                        "dynamicRegistration": True,
+                        "symbolKind": {"valueSet": list(range(1, 27))},
+                        "hierarchicalDocumentSymbolSupport": True,
+                        "tagSupport": {"valueSet": [1]},
+                        "labelSupport": True,
+                    },
+                    "rename": {
+                        "dynamicRegistration": True,
+                        "prepareSupport": True,
+                        "prepareSupportDefaultBehavior": 1,
+                        "honorsChangeAnnotations": True,
+                    },
+                    "documentLink": {"dynamicRegistration": True, "tooltipSupport": True},
+                    "typeDefinition": {"dynamicRegistration": True, "linkSupport": True},
+                    "implementation": {"dynamicRegistration": True, "linkSupport": True},
+                    "colorProvider": {"dynamicRegistration": True},
+                    "declaration": {"dynamicRegistration": True, "linkSupport": True},
+                    "selectionRange": {"dynamicRegistration": True},
+                    "callHierarchy": {"dynamicRegistration": True},
+                    "semanticTokens": {
+                        "dynamicRegistration": True,
+                        "tokenTypes": [
+                            "namespace",
+                            "type",
+                            "class",
+                            "enum",
+                            "interface",
+                            "struct",
+                            "typeParameter",
+                            "parameter",
+                            "variable",
+                            "property",
+                            "enumMember",
+                            "event",
+                            "function",
+                            "method",
+                            "macro",
+                            "keyword",
+                            "modifier",
+                            "comment",
+                            "string",
+                            "number",
+                            "regexp",
+                            "operator",
+                            "decorator",
+                        ],
+                        "tokenModifiers": [
+                            "declaration",
+                            "definition",
+                            "readonly",
+                            "static",
+                            "deprecated",
+                            "abstract",
+                            "async",
+                            "modification",
+                            "documentation",
+                            "defaultLibrary",
+                        ],
+                        "formats": ["relative"],
+                        "requests": {"range": True, "full": {"delta": True}},
+                        "multilineTokenSupport": False,
+                        "overlappingTokenSupport": False,
+                        "serverCancelSupport": True,
+                        "augmentsSyntaxTokens": True,
+                    },
+                    "typeHierarchy": {"dynamicRegistration": True},
+                    "inlineValue": {"dynamicRegistration": True},
+                    "diagnostic": {"dynamicRegistration": True, "relatedDocumentSupport": False},
+                },
+                "general": {
+                    "staleRequestSupport": {
+                        "cancel": True,
+                        "retryOnContentModified": [
+                            "textDocument/semanticTokens/full",
+                            "textDocument/semanticTokens/range",
+                            "textDocument/semanticTokens/full/delta",
+                        ],
+                    },
+                    "regularExpressions": {"engine": "ECMAScript", "version": "ES2020"},
+                    "positionEncodings": ["utf-16"],
+                },
+                "notebookDocument": {"synchronization": {"dynamicRegistration": True, "executionSummarySupport": True}},
+            },
+            "initializationOptions": {
+                "bundles": ["intellicode-core.jar"],
+                "settings": {
+                    "java": {
+                        "home": None,
+                        "jdt": {
+                            "ls": {
+                                "java": {"home": None},
+                                "vmargs": "-XX:+UseParallelGC -XX:GCTimeRatio=4 -XX:AdaptiveSizePolicyWeight=90 -Dsun.zip.disableMemoryMapping=true -Xmx1G -Xms100m -Xlog:disable",
+                                "lombokSupport": {"enabled": True},
+                                "protobufSupport": {"enabled": True},
+                                "androidSupport": {"enabled": True},
+                            }
+                        },
+                        "errors": {"incompleteClasspath": {"severity": "error"}},
+                        "configuration": {
+                            "checkProjectSettingsExclusions": False,
+                            "updateBuildConfiguration": "interactive",
+                            "maven": {
+                                "userSettings": None,
+                                "globalSettings": None,
+                                "notCoveredPluginExecutionSeverity": "warning",
+                                "defaultMojoExecutionAction": "ignore",
+                            },
+                            "workspaceCacheLimit": 90,
+                            "runtimes": [
+                                {"name": "JavaSE-21", "path": "static/vscode-java/extension/jre/21.0.7-linux-x86_64", "default": True}
+                            ],
+                        },
+                        "trace": {"server": "verbose"},
+                        "import": {
+                            "maven": {
+                                "enabled": True,
+                                "offline": {"enabled": False},
+                                "disableTestClasspathFlag": False,
+                            },
+                            "gradle": {
+                                "enabled": True,
+                                "wrapper": {"enabled": False},
+                                "version": None,
+                                "home": "abs(static/gradle-7.3.3)",
+                                "java": {"home": "abs(static/launch_jres/21.0.7-linux-x86_64)"},
+                                "offline": {"enabled": False},
+                                "arguments": None,
+                                "jvmArguments": None,
+                                "user": {"home": None},
+                                "annotationProcessing": {"enabled": True},
+                            },
+                            "exclusions": [
+                                "**/node_modules/**",
+                                "**/.metadata/**",
+                                "**/archetype-resources/**",
+                                "**/META-INF/maven/**",
+                            ],
+                            "generatesMetadataFilesAtProjectRoot": False,
+                        },
+                        "maven": {"downloadSources": True, "updateSnapshots": True},
+                        "eclipse": {"downloadSources": True},
+                        "signatureHelp": {"enabled": True, "description": {"enabled": True}},
+                        "implementationsCodeLens": {"enabled": True},
+                        "format": {
+                            "enabled": True,
+                            "settings": {"url": None, "profile": None},
+                            "comments": {"enabled": True},
+                            "onType": {"enabled": True},
+                            "insertSpaces": True,
+                            "tabSize": 4,
+                        },
+                        "saveActions": {"organizeImports": False},
+                        "project": {
+                            "referencedLibraries": ["lib/**/*.jar"],
+                            "importOnFirstTimeStartup": "automatic",
+                            "importHint": True,
+                            "resourceFilters": ["node_modules", "\\.git"],
+                            "encoding": "ignore",
+                            "exportJar": {"targetPath": "${workspaceFolder}/${workspaceFolderBasename}.jar"},
+                        },
+                        "contentProvider": {"preferred": None},
+                        "autobuild": {"enabled": True},
+                        "maxConcurrentBuilds": 1,
+                        "selectionRange": {"enabled": True},
+                        "showBuildStatusOnStart": {"enabled": "notification"},
+                        "server": {"launchMode": "Standard"},
+                        "sources": {"organizeImports": {"starThreshold": 99, "staticStarThreshold": 99}},
+                        "imports": {"gradle": {"wrapper": {"checksums": []}}},
+                        "templates": {"fileHeader": [], "typeComment": []},
+                        "references": {"includeAccessors": True, "includeDecompiledSources": True},
+                        "typeHierarchy": {"lazyLoad": False},
+                        "settings": {"url": None},
+                        "symbols": {"includeSourceMethodDeclarations": False},
+                        "inlayHints": {"parameterNames": {"enabled": "literals", "exclusions": []}},
+                        "codeAction": {"sortMembers": {"avoidVolatileChanges": True}},
+                        "compile": {
+                            "nullAnalysis": {
+                                "nonnull": [
+                                    "javax.annotation.Nonnull",
+                                    "org.eclipse.jdt.annotation.NonNull",
+                                    "org.springframework.lang.NonNull",
+                                ],
+                                "nullable": [
+                                    "javax.annotation.Nullable",
+                                    "org.eclipse.jdt.annotation.Nullable",
+                                    "org.springframework.lang.Nullable",
+                                ],
+                                "mode": "automatic",
+                            }
+                        },
+                        "sharedIndexes": {"enabled": "auto", "location": ""},
+                        "silentNotification": False,
+                        "dependency": {
+                            "showMembers": False,
+                            "syncWithFolderExplorer": True,
+                            "autoRefresh": True,
+                            "refreshDelay": 2000,
+                            "packagePresentation": "flat",
+                        },
+                        "help": {"firstView": "auto", "showReleaseNotes": True, "collectErrorLog": False},
+                        "test": {"defaultConfig": "", "config": {}},
+                    }
+                },
+            },
+            "trace": "verbose",
+            "processId": os.getpid(),
+            "workspaceFolders": [
+                {
+                    "uri": repo_uri,
+                    "name": os.path.basename(repository_absolute_path),
+                }
+            ],
+        }
+
+        initialize_params["initializationOptions"]["workspaceFolders"] = [repo_uri]
+        bundles = [self.runtime_dependency_paths.intellicode_jar_path]
+        initialize_params["initializationOptions"]["bundles"] = bundles
+        initialize_params["initializationOptions"]["settings"]["java"]["configuration"]["runtimes"] = [
+            {"name": "JavaSE-21", "path": self.runtime_dependency_paths.jre_home_path, "default": True}
+        ]
+
+        for runtime in initialize_params["initializationOptions"]["settings"]["java"]["configuration"]["runtimes"]:
+            assert "name" in runtime
+            assert "path" in runtime
+            assert os.path.exists(runtime["path"]), f"Runtime required for eclipse_jdtls at path {runtime['path']} does not exist"
+
+        gradle_settings = initialize_params["initializationOptions"]["settings"]["java"]["import"]["gradle"]
+        gradle_settings["home"] = self.runtime_dependency_paths.gradle_path
+        gradle_settings["java"]["home"] = self.runtime_dependency_paths.jre_path
+        return initialize_params
+
+    def _start_server(self):
+        """
+        Starts the Eclipse JDTLS Language Server
+        """
+
+        def register_capability_handler(params):
+            assert "registrations" in params
+            for registration in params["registrations"]:
+                if registration["method"] == "textDocument/completion":
+                    assert registration["registerOptions"]["resolveProvider"] == True
+                    assert registration["registerOptions"]["triggerCharacters"] == [
+                        ".",
+                        "@",
+                        "#",
+                        "*",
+                        " ",
+                    ]
+                    self.completions_available.set()
+                if registration["method"] == "workspace/executeCommand":
+                    if "java.intellicode.enable" in registration["registerOptions"]["commands"]:
+                        self.intellicode_enable_command_available.set()
+            return
+
+        def lang_status_handler(params):
+            # TODO: Should we wait for
+            # server -> client: {'jsonrpc': '2.0', 'method': 'language/status', 'params': {'type': 'ProjectStatus', 'message': 'OK'}}
+            # Before proceeding?
+            if params["type"] == "ServiceReady" and params["message"] == "ServiceReady":
+                self.service_ready_event.set()
+
+        def execute_client_command_handler(params):
+            assert params["command"] == "_java.reloadBundles.command"
+            assert params["arguments"] == []
+            return []
+
+        def window_log_message(msg):
+            self.logger.log(f"LSP: window/logMessage: {msg}", logging.INFO)
+
+        def do_nothing(params):
+            return
+
+        self.server.on_request("client/registerCapability", register_capability_handler)
+        self.server.on_notification("language/status", lang_status_handler)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_request("workspace/executeClientCommand", execute_client_command_handler)
+        self.server.on_notification("$/progress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+        self.server.on_notification("language/actionableNotification", do_nothing)
+
+        self.logger.log("Starting EclipseJDTLS server process", logging.INFO)
+        self.server.start()
+        initialize_params = self._get_initialize_params(self.repository_root_path)
+
+        self.logger.log(
+            "Sending initialize request from LSP client to LSP server and awaiting response",
+            logging.INFO,
+        )
+        init_response = self.server.send.initialize(initialize_params)
+        assert init_response["capabilities"]["textDocumentSync"]["change"] == 2
+        assert "completionProvider" not in init_response["capabilities"]
+        assert "executeCommandProvider" not in init_response["capabilities"]
+
+        self.server.notify.initialized({})
+
+        self.server.notify.workspace_did_change_configuration({"settings": initialize_params["initializationOptions"]["settings"]})
+
+        self.intellicode_enable_command_available.wait()
+
+        java_intellisense_members_path = self.runtime_dependency_paths.intellisense_members_path
+        assert os.path.exists(java_intellisense_members_path)
+        intellicode_enable_result = self.server.send.execute_command(
+            {
+                "command": "java.intellicode.enable",
+                "arguments": [True, java_intellisense_members_path],
+            }
+        )
+        assert intellicode_enable_result
+
+        # TODO: Add comments about why we wait here, and how this can be optimized
+        self.service_ready_event.wait()

projects/ui/serena-new/src/solidlsp/language_servers/erlang_language_server.py

@@ -0,0 +1,230 @@
+"""Erlang Language Server implementation using Erlang LS."""
+
+import logging
+import os
+import shutil
+import subprocess
+import threading
+import time
+
+from overrides import override
+
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+
+class ErlangLanguageServer(SolidLanguageServer):
+    """Language server for Erlang using Erlang LS."""
+
+    def __init__(
+        self,
+        config: LanguageServerConfig,
+        logger: LanguageServerLogger,
+        repository_root_path: str,
+        solidlsp_settings: SolidLSPSettings,
+    ):
+        """
+        Creates an ErlangLanguageServer instance. This class is not meant to be instantiated directly.
+        Use LanguageServer.create() instead.
+        """
+        self.erlang_ls_path = shutil.which("erlang_ls")
+        if not self.erlang_ls_path:
+            raise RuntimeError("Erlang LS not found. Install from: https://github.com/erlang-ls/erlang_ls")
+
+        if not self._check_erlang_installation():
+            raise RuntimeError("Erlang/OTP not found. Install from: https://www.erlang.org/downloads")
+
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=[self.erlang_ls_path, "--transport", "stdio"], cwd=repository_root_path),
+            "erlang",
+            solidlsp_settings,
+        )
+
+        # Add server readiness tracking like Elixir
+        self.server_ready = threading.Event()
+
+        # Set generous timeout for Erlang LS initialization
+        self.set_request_timeout(120.0)
+
+    def _check_erlang_installation(self) -> bool:
+        """Check if Erlang/OTP is available."""
+        try:
+            result = subprocess.run(["erl", "-version"], check=False, capture_output=True, text=True, timeout=10)
+            return result.returncode == 0
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False
+
+    @classmethod
+    def _get_erlang_version(cls):
+        """Get the installed Erlang/OTP version or None if not found."""
+        try:
+            result = subprocess.run(["erl", "-version"], check=False, capture_output=True, text=True, timeout=10)
+            if result.returncode == 0:
+                return result.stderr.strip()  # erl -version outputs to stderr
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return None
+        return None
+
+    @classmethod
+    def _check_rebar3_available(cls) -> bool:
+        """Check if rebar3 build tool is available."""
+        try:
+            result = subprocess.run(["rebar3", "version"], check=False, capture_output=True, text=True, timeout=10)
+            return result.returncode == 0
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False
+
+    def _start_server(self):
+        """Start Erlang LS server process with proper initialization waiting."""
+
+        def register_capability_handler(params):
+            return
+
+        def window_log_message(msg):
+            """Handle window/logMessage notifications from Erlang LS"""
+            message_text = msg.get("message", "")
+            self.logger.log(f"LSP: window/logMessage: {message_text}", logging.INFO)
+
+            # Look for Erlang LS readiness signals
+            # Common patterns: "Started Erlang LS", "initialized", "ready"
+            readiness_signals = [
+                "Started Erlang LS",
+                "server started",
+                "initialized",
+                "ready to serve requests",
+                "compilation finished",
+                "indexing complete",
+            ]
+
+            message_lower = message_text.lower()
+            for signal in readiness_signals:
+                if signal.lower() in message_lower:
+                    self.logger.log(f"Erlang LS readiness signal detected: {message_text}", logging.INFO)
+                    self.server_ready.set()
+                    break
+
+        def do_nothing(params):
+            return
+
+        def check_server_ready(params):
+            """Handle $/progress notifications from Erlang LS as fallback."""
+            value = params.get("value", {})
+
+            # Check for initialization completion progress
+            if value.get("kind") == "end":
+                message = value.get("message", "")
+                if any(word in message.lower() for word in ["initialized", "ready", "complete"]):
+                    self.logger.log("Erlang LS initialization progress completed", logging.INFO)
+                    # Set as fallback if no window/logMessage was received
+                    if not self.server_ready.is_set():
+                        self.server_ready.set()
+
+        # Set up notification handlers
+        self.server.on_request("client/registerCapability", register_capability_handler)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_notification("$/progress", check_server_ready)
+        self.server.on_notification("window/workDoneProgress/create", do_nothing)
+        self.server.on_notification("$/workDoneProgress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+
+        self.logger.log("Starting Erlang LS server process", logging.INFO)
+        self.server.start()
+
+        # Send initialize request
+        initialize_params = {
+            "processId": None,
+            "rootPath": self.repository_root_path,
+            "rootUri": f"file://{self.repository_root_path}",
+            "capabilities": {
+                "textDocument": {
+                    "synchronization": {"didSave": True},
+                    "completion": {"dynamicRegistration": True},
+                    "definition": {"dynamicRegistration": True},
+                    "references": {"dynamicRegistration": True},
+                    "documentSymbol": {"dynamicRegistration": True},
+                    "hover": {"dynamicRegistration": True},
+                }
+            },
+        }
+
+        self.logger.log("Sending initialize request to Erlang LS", logging.INFO)
+        init_response = self.server.send.initialize(initialize_params)
+
+        # Verify server capabilities
+        if "capabilities" in init_response:
+            self.logger.log(f"Erlang LS capabilities: {list(init_response['capabilities'].keys())}", logging.INFO)
+
+        self.server.notify.initialized({})
+        self.completions_available.set()
+
+        # Wait for Erlang LS to be ready - adjust timeout based on environment
+        is_ci = os.getenv("CI") == "true" or os.getenv("GITHUB_ACTIONS") == "true"
+        is_macos = os.uname().sysname == "Darwin" if hasattr(os, "uname") else False
+
+        # macOS in CI can be particularly slow for language server startup
+        if is_ci and is_macos:
+            ready_timeout = 240.0  # 4 minutes for macOS CI
+            env_desc = "macOS CI"
+        elif is_ci:
+            ready_timeout = 180.0  # 3 minutes for other CI
+            env_desc = "CI"
+        else:
+            ready_timeout = 60.0  # 1 minute for local
+            env_desc = "local"
+
+        self.logger.log(f"Waiting up to {ready_timeout} seconds for Erlang LS readiness ({env_desc} environment)...", logging.INFO)
+
+        if self.server_ready.wait(timeout=ready_timeout):
+            self.logger.log("Erlang LS is ready and available for requests", logging.INFO)
+
+            # Add settling period for indexing - adjust based on environment
+            settling_time = 15.0 if is_ci else 5.0
+            self.logger.log(f"Allowing {settling_time} seconds for Erlang LS indexing to complete...", logging.INFO)
+            time.sleep(settling_time)
+            self.logger.log("Erlang LS settling period complete", logging.INFO)
+        else:
+            # Set ready anyway and continue - Erlang LS might not send explicit ready messages
+            self.logger.log(
+                f"Erlang LS readiness timeout reached after {ready_timeout}s, proceeding anyway (common in CI)", logging.WARNING
+            )
+            self.server_ready.set()
+
+            # Still give some time for basic initialization even without explicit readiness signal
+            basic_settling_time = 20.0 if is_ci else 10.0
+            self.logger.log(f"Allowing {basic_settling_time} seconds for basic Erlang LS initialization...", logging.INFO)
+            time.sleep(basic_settling_time)
+            self.logger.log("Basic Erlang LS initialization period complete", logging.INFO)
+
+    @override
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        # For Erlang projects, we should ignore:
+        # - _build: rebar3 build artifacts
+        # - deps: dependencies
+        # - ebin: compiled beam files
+        # - .rebar3: rebar3 cache
+        # - logs: log files
+        # - node_modules: if the project has JavaScript components
+        return super().is_ignored_dirname(dirname) or dirname in [
+            "_build",
+            "deps",
+            "ebin",
+            ".rebar3",
+            "logs",
+            "node_modules",
+            "_checkouts",
+            "cover",
+        ]
+
+    def is_ignored_filename(self, filename: str) -> bool:
+        """Check if a filename should be ignored."""
+        # Ignore compiled BEAM files
+        if filename.endswith(".beam"):
+            return True
+        # Don't ignore Erlang source files, header files, or configuration files
+        return False

projects/ui/serena-new/src/solidlsp/language_servers/gopls.py

@@ -0,0 +1,159 @@
+import logging
+import os
+import pathlib
+import subprocess
+import threading
+
+from overrides import override
+
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.lsp_protocol_handler.lsp_types import InitializeParams
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+
+class Gopls(SolidLanguageServer):
+    """
+    Provides Go specific instantiation of the LanguageServer class using gopls.
+    """
+
+    @override
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        # For Go projects, we should ignore:
+        # - vendor: third-party dependencies vendored into the project
+        # - node_modules: if the project has JavaScript components
+        # - dist/build: common output directories
+        return super().is_ignored_dirname(dirname) or dirname in ["vendor", "node_modules", "dist", "build"]
+
+    @staticmethod
+    def _get_go_version():
+        """Get the installed Go version or None if not found."""
+        try:
+            result = subprocess.run(["go", "version"], capture_output=True, text=True, check=False)
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except FileNotFoundError:
+            return None
+        return None
+
+    @staticmethod
+    def _get_gopls_version():
+        """Get the installed gopls version or None if not found."""
+        try:
+            result = subprocess.run(["gopls", "version"], capture_output=True, text=True, check=False)
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except FileNotFoundError:
+            return None
+        return None
+
+    @staticmethod
+    def _setup_runtime_dependency():
+        """
+        Check if required Go runtime dependencies are available.
+        Raises RuntimeError with helpful message if dependencies are missing.
+        """
+        go_version = Gopls._get_go_version()
+        if not go_version:
+            raise RuntimeError(
+                "Go is not installed. Please install Go from https://golang.org/doc/install and make sure it is added to your PATH."
+            )
+
+        gopls_version = Gopls._get_gopls_version()
+        if not gopls_version:
+            raise RuntimeError(
+                "Found a Go version but gopls is not installed.\n"
+                "Please install gopls as described in https://pkg.go.dev/golang.org/x/tools/gopls#section-readme\n\n"
+                "After installation, make sure it is added to your PATH (it might be installed in a different location than Go)."
+            )
+
+        return True
+
+    def __init__(
+        self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str, solidlsp_settings: SolidLSPSettings
+    ):
+        self._setup_runtime_dependency()
+
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd="gopls", cwd=repository_root_path),
+            "go",
+            solidlsp_settings,
+        )
+        self.server_ready = threading.Event()
+        self.request_id = 0
+
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
+        """
+        Returns the initialize params for the Go Language Server.
+        """
+        root_uri = pathlib.Path(repository_absolute_path).as_uri()
+        initialize_params = {
+            "locale": "en",
+            "capabilities": {
+                "textDocument": {
+                    "synchronization": {"didSave": True, "dynamicRegistration": True},
+                    "definition": {"dynamicRegistration": True},
+                    "documentSymbol": {
+                        "dynamicRegistration": True,
+                        "hierarchicalDocumentSymbolSupport": True,
+                        "symbolKind": {"valueSet": list(range(1, 27))},
+                    },
+                },
+                "workspace": {"workspaceFolders": True, "didChangeConfiguration": {"dynamicRegistration": True}},
+            },
+            "processId": os.getpid(),
+            "rootPath": repository_absolute_path,
+            "rootUri": root_uri,
+            "workspaceFolders": [
+                {
+                    "uri": root_uri,
+                    "name": os.path.basename(repository_absolute_path),
+                }
+            ],
+        }
+        return initialize_params
+
+    def _start_server(self):
+        """Start gopls server process"""
+
+        def register_capability_handler(params):
+            return
+
+        def window_log_message(msg):
+            self.logger.log(f"LSP: window/logMessage: {msg}", logging.INFO)
+
+        def do_nothing(params):
+            return
+
+        self.server.on_request("client/registerCapability", register_capability_handler)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_notification("$/progress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+
+        self.logger.log("Starting gopls server process", logging.INFO)
+        self.server.start()
+        initialize_params = self._get_initialize_params(self.repository_root_path)
+
+        self.logger.log(
+            "Sending initialize request from LSP client to LSP server and awaiting response",
+            logging.INFO,
+        )
+        init_response = self.server.send.initialize(initialize_params)
+
+        # Verify server capabilities
+        assert "textDocumentSync" in init_response["capabilities"]
+        assert "completionProvider" in init_response["capabilities"]
+        assert "definitionProvider" in init_response["capabilities"]
+
+        self.server.notify.initialized({})
+        self.completions_available.set()
+
+        # gopls server is typically ready immediately after initialization
+        self.server_ready.set()
+        self.server_ready.wait()