Add files using upload-large-folder tool

projects/ui/serena-new/src/solidlsp/language_servers/elixir_tools/README.md

@@ -0,0 +1,90 @@
+# Elixir Language Server Integration
+
+This directory contains the integration for Elixir language support using [Next LS](https://github.com/elixir-tools/next-ls) from the elixir-tools project.
+
+> **⚠️ Windows Not Supported**: Next LS does not provide Windows binaries, so Elixir language server integration is only available on Linux and macOS.
+
+## Known Issues
+
+### Next LS v0.23.3 Timeout Enumeration Bug
+There is a known intermittent bug in Next LS v0.23.3 where `textDocument/definition` requests can fail with:
+```
+Protocol.UndefinedError: protocol Enumerable not implemented for :timeout of type Atom
+```
+
+This bug is tracked in [Next LS Issue #543](https://github.com/elixir-tools/next-ls/issues/543) and primarily occurs in CI environments. The affected test (`test_request_defining_symbol_none`) is marked as expected to fail until this upstream bug is resolved.
+
+## Prerequisites
+
+Before using the Elixir language server integration, you need to have:
+
+1. **Elixir** installed and available in your PATH
+   - Install from: https://elixir-lang.org/install.html
+   - Verify with: `elixir --version`
+
+2. **Next LS** installed and available in your PATH
+   - Install from: https://github.com/elixir-tools/next-ls#installation
+   - Verify with: `nextls --version`
+
+## Features
+
+The Elixir integration provides:
+
+- **Language Server Protocol (LSP) support** via Next LS
+- **File extension recognition** for `.ex` and `.exs` files
+- **Project structure awareness** with proper handling of Elixir-specific directories:
+  - `_build/` - Compiled artifacts (ignored)
+  - `deps/` - Dependencies (ignored)
+  - `.elixir_ls/` - ElixirLS artifacts (ignored)
+  - `cover/` - Coverage reports (ignored)
+  - `lib/` - Source code (not ignored)
+  - `test/` - Test files (not ignored)
+
+## Configuration
+
+The integration uses the default Next LS configuration with:
+
+- **MIX_ENV**: `dev`
+- **MIX_TARGET**: `host`
+- **Experimental completions**: Disabled by default
+- **Credo extension**: Enabled by default
+
+## Usage
+
+The Elixir language server is automatically selected when working with Elixir projects. It will be used for:
+
+- Code completion
+- Go to definition
+- Find references
+- Document symbols
+- Hover information
+- Code formatting
+- Diagnostics (via Credo integration)
+
+### Important: Project Compilation
+
+Next LS requires your Elixir project to be **compiled** for optimal performance, especially for:
+- Cross-file reference resolution
+- Complete symbol information
+- Accurate go-to-definition
+
+**For production use**: Ensure your project is compiled with `mix compile` before using the language server.
+
+**For testing**: The test suite automatically compiles the test repositories before running tests to ensure optimal Next LS performance.
+
+## Testing
+
+Run the Elixir-specific tests with:
+
+```bash
+pytest test/solidlsp/elixir/ -m elixir
+```
+
+## Implementation Details
+
+- **Main class**: `ElixirTools` in `elixir_tools.py`
+- **Initialization parameters**: Defined in `initialize_params.json`
+- **Language identifier**: `"elixir"`
+- **Command**: `nextls --stdio`
+
+The implementation follows the same patterns as other language servers in this project, inheriting from `SolidLanguageServer` and providing Elixir-specific configuration and behavior. 

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,353 @@
+import logging
+import os
+import pathlib
+import stat
+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.ls_utils import FileUtils, PlatformId, PlatformUtils
+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
+
+
+class ElixirTools(SolidLanguageServer):
+    """
+    Provides Elixir specific instantiation of the LanguageServer class using Next LS from elixir-tools.
+    """
+
+    @override
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        # For Elixir projects, we should ignore:
+        # - _build: compiled artifacts
+        # - deps: dependencies
+        # - node_modules: if the project has JavaScript components
+        # - .elixir_ls: ElixirLS artifacts (in case both are present)
+        # - cover: coverage reports
+        return super().is_ignored_dirname(dirname) or dirname in ["_build", "deps", "node_modules", ".elixir_ls", "cover"]
+
+    def _is_next_ls_internal_file(self, abs_path: str) -> bool:
+        """Check if an absolute path is a Next LS internal file that should be ignored."""
+        return any(
+            pattern in abs_path
+            for pattern in [
+                ".burrito",  # Next LS runtime directory
+                "next_ls_erts-",  # Next LS Erlang runtime
+                "_next_ls_private_",  # Next LS private files
+                "/priv/monkey/",  # Next LS monkey patching directory
+            ]
+        )
+
+    @override
+    def _send_references_request(self, relative_file_path: str, line: int, column: int):
+        """Override to filter out Next LS internal files from references."""
+        from solidlsp.ls_utils import PathUtils
+
+        # Get the raw response from the parent implementation
+        raw_response = super()._send_references_request(relative_file_path, line, column)
+
+        if raw_response is None:
+            return None
+
+        # Filter out Next LS internal files
+        filtered_response = []
+        for item in raw_response:
+            if isinstance(item, dict) and "uri" in item:
+                abs_path = PathUtils.uri_to_path(item["uri"])
+                if self._is_next_ls_internal_file(abs_path):
+                    self.logger.log(f"Filtering out Next LS internal file: {abs_path}", logging.DEBUG)
+                    continue
+            filtered_response.append(item)
+
+        return filtered_response
+
+    @classmethod
+    def _get_elixir_version(cls):
+        """Get the installed Elixir version or None if not found."""
+        try:
+            result = subprocess.run(["elixir", "--version"], capture_output=True, text=True, check=False)
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except FileNotFoundError:
+            return None
+        return None
+
+    @classmethod
+    def _setup_runtime_dependencies(
+        cls, logger: LanguageServerLogger, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings
+    ) -> str:
+        """
+        Setup runtime dependencies for Next LS.
+        Downloads the Next LS binary for the current platform and returns the path to the executable.
+        """
+        # Check if Elixir is available first
+        elixir_version = cls._get_elixir_version()
+        if not elixir_version:
+            raise RuntimeError(
+                "Elixir is not installed. Please install Elixir from https://elixir-lang.org/install.html and make sure it is added to your PATH."
+            )
+
+        logger.log(f"Found Elixir: {elixir_version}", logging.INFO)
+
+        platform_id = PlatformUtils.get_platform_id()
+
+        # Check for Windows and provide a helpful error message
+        if platform_id.value.startswith("win"):
+            raise RuntimeError(
+                "Windows is not supported by Next LS. The Next LS project does not provide Windows binaries. "
+                "Consider using Windows Subsystem for Linux (WSL) or a virtual machine with Linux/macOS."
+            )
+
+        valid_platforms = [
+            PlatformId.LINUX_x64,
+            PlatformId.LINUX_arm64,
+            PlatformId.OSX_x64,
+            PlatformId.OSX_arm64,
+        ]
+        assert platform_id in valid_platforms, f"Platform {platform_id} is not supported for Next LS at the moment"
+
+        next_ls_dir = os.path.join(cls.ls_resources_dir(solidlsp_settings), "next-ls")
+
+        NEXTLS_VERSION = "v0.23.4"
+
+        # Define runtime dependencies inline
+        runtime_deps = {
+            PlatformId.LINUX_x64: RuntimeDependency(
+                id="next_ls_linux_amd64",
+                platform_id="linux-x64",
+                url=f"https://github.com/elixir-tools/next-ls/releases/download/{NEXTLS_VERSION}/next_ls_linux_amd64",
+                archive_type="binary",
+                binary_name="next_ls_linux_amd64",
+                extract_path="next_ls",
+            ),
+            PlatformId.LINUX_arm64: RuntimeDependency(
+                id="next_ls_linux_arm64",
+                platform_id="linux-arm64",
+                url=f"https://github.com/elixir-tools/next-ls/releases/download/{NEXTLS_VERSION}/next_ls_linux_arm64",
+                archive_type="binary",
+                binary_name="next_ls_linux_arm64",
+                extract_path="next_ls",
+            ),
+            PlatformId.OSX_x64: RuntimeDependency(
+                id="next_ls_darwin_amd64",
+                platform_id="osx-x64",
+                url=f"https://github.com/elixir-tools/next-ls/releases/download/{NEXTLS_VERSION}/next_ls_darwin_amd64",
+                archive_type="binary",
+                binary_name="next_ls_darwin_amd64",
+                extract_path="next_ls",
+            ),
+            PlatformId.OSX_arm64: RuntimeDependency(
+                id="next_ls_darwin_arm64",
+                platform_id="osx-arm64",
+                url=f"https://github.com/elixir-tools/next-ls/releases/download/{NEXTLS_VERSION}/next_ls_darwin_arm64",
+                archive_type="binary",
+                binary_name="next_ls_darwin_arm64",
+                extract_path="next_ls",
+            ),
+        }
+
+        dependency = runtime_deps[platform_id]
+        executable_path = os.path.join(next_ls_dir, "nextls")
+        binary_path = os.path.join(next_ls_dir, dependency.binary_name)
+
+        if not os.path.exists(executable_path):
+            logger.log(f"Downloading Next LS binary from {dependency.url}", logging.INFO)
+            FileUtils.download_file(logger, dependency.url, binary_path)
+
+            # Make the binary executable on Unix-like systems
+            os.chmod(binary_path, stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH)
+
+            # Create a symlink with the expected name
+            if binary_path != executable_path:
+                if os.path.exists(executable_path):
+                    os.remove(executable_path)
+                os.symlink(os.path.basename(binary_path), executable_path)
+
+        assert os.path.exists(executable_path), f"Next LS executable not found at {executable_path}"
+
+        logger.log(f"Next LS binary ready at: {executable_path}", logging.INFO)
+        return executable_path
+
+    def __init__(
+        self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str, solidlsp_settings: SolidLSPSettings
+    ):
+        nextls_executable_path = self._setup_runtime_dependencies(logger, config, solidlsp_settings)
+
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=f'"{nextls_executable_path}" --stdio', cwd=repository_root_path),
+            "elixir",
+            solidlsp_settings,
+        )
+        self.server_ready = threading.Event()
+        self.request_id = 0
+
+        # Set generous timeout for Next LS which can be slow to initialize and respond
+        self.set_request_timeout(180.0)  # 60 seconds for all environments
+
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
+        """
+        Returns the initialize params for the Next LS Language Server.
+        """
+        root_uri = pathlib.Path(repository_absolute_path).as_uri()
+        initialize_params = {
+            "processId": os.getpid(),
+            "locale": "en",
+            "rootPath": repository_absolute_path,
+            "rootUri": root_uri,
+            "initializationOptions": {
+                "mix_env": "dev",
+                "mix_target": "host",
+                "experimental": {"completions": {"enable": False}},
+                "extensions": {"credo": {"enable": True, "cli_options": []}},
+            },
+            "capabilities": {
+                "textDocument": {
+                    "synchronization": {"didSave": True, "dynamicRegistration": True},
+                    "completion": {
+                        "dynamicRegistration": True,
+                        "completionItem": {"snippetSupport": True, "documentationFormat": ["markdown", "plaintext"]},
+                    },
+                    "definition": {"dynamicRegistration": True},
+                    "references": {"dynamicRegistration": True},
+                    "documentSymbol": {
+                        "dynamicRegistration": True,
+                        "hierarchicalDocumentSymbolSupport": True,
+                        "symbolKind": {"valueSet": list(range(1, 27))},
+                    },
+                    "hover": {"dynamicRegistration": True, "contentFormat": ["markdown", "plaintext"]},
+                    "formatting": {"dynamicRegistration": True},
+                    "codeAction": {
+                        "dynamicRegistration": True,
+                        "codeActionLiteralSupport": {
+                            "codeActionKind": {
+                                "valueSet": [
+                                    "quickfix",
+                                    "refactor",
+                                    "refactor.extract",
+                                    "refactor.inline",
+                                    "refactor.rewrite",
+                                    "source",
+                                    "source.organizeImports",
+                                ]
+                            }
+                        },
+                    },
+                },
+                "workspace": {
+                    "workspaceFolders": True,
+                    "didChangeConfiguration": {"dynamicRegistration": True},
+                    "executeCommand": {"dynamicRegistration": True},
+                },
+            },
+            "workspaceFolders": [{"uri": root_uri, "name": os.path.basename(repository_absolute_path)}],
+        }
+
+        return initialize_params
+
+    def _start_server(self):
+        """Start Next LS server process"""
+
+        def register_capability_handler(params):
+            return
+
+        def window_log_message(msg):
+            """Handle window/logMessage notifications from Next LS"""
+            message_text = msg.get("message", "")
+            self.logger.log(f"LSP: window/logMessage: {message_text}", logging.INFO)
+
+            # Check for the specific Next LS readiness signal
+            # Based on Next LS source: "Runtime for folder #{name} is ready..."
+            if "Runtime for folder" in message_text and "is ready..." in message_text:
+                self.logger.log("Next LS runtime is ready based on official log message", logging.INFO)
+                self.server_ready.set()
+
+        def do_nothing(params):
+            return
+
+        def check_server_ready(params):
+            """
+            Handle $/progress notifications from Next LS.
+            Keep as fallback for error detection, but primary readiness detection
+            is now done via window/logMessage handler.
+            """
+            value = params.get("value", {})
+
+            # Check for initialization completion progress (fallback signal)
+            if value.get("kind") == "end":
+                message = value.get("message", "")
+                if "has initialized!" in message:
+                    self.logger.log("Next LS initialization progress completed", logging.INFO)
+                    # Note: We don't set server_ready here - we wait for the log message
+
+        def work_done_progress(params):
+            """
+            Handle $/workDoneProgress notifications from Next LS.
+            Keep for completeness but primary readiness detection is via window/logMessage.
+            """
+            value = params.get("value", {})
+            if value.get("kind") == "end":
+                self.logger.log("Next LS work done progress completed", logging.INFO)
+                # Note: We don't set server_ready here - we wait for the log message
+
+        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", work_done_progress)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+
+        self.logger.log("Starting Next LS 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 - be more lenient with Next LS
+        self.logger.log(f"Next LS capabilities: {list(init_response['capabilities'].keys())}", logging.INFO)
+
+        # Next LS may not provide all capabilities immediately, so we check for basic ones
+        assert "textDocumentSync" in init_response["capabilities"], f"Missing textDocumentSync in {init_response['capabilities']}"
+
+        # Some capabilities might be optional or provided later
+        if "completionProvider" not in init_response["capabilities"]:
+            self.logger.log("Warning: completionProvider not available in initial capabilities", logging.WARNING)
+        if "definitionProvider" not in init_response["capabilities"]:
+            self.logger.log("Warning: definitionProvider not available in initial capabilities", logging.WARNING)
+
+        self.server.notify.initialized({})
+        self.completions_available.set()
+
+        # Wait for Next LS to send the specific "Runtime for folder X is ready..." log message
+        # This is the authoritative signal that Next LS is truly ready for requests
+        ready_timeout = 180.0
+        self.logger.log(f"Waiting up to {ready_timeout} seconds for Next LS runtime readiness...", logging.INFO)
+
+        if self.server_ready.wait(timeout=ready_timeout):
+            self.logger.log("Next LS is ready and available for requests", logging.INFO)
+
+            # Add a small settling period to ensure background indexing is complete
+            # Next LS often continues compilation/indexing in background after ready signal
+            settling_time = 120.0
+            self.logger.log(f"Allowing {settling_time} seconds for Next LS background indexing to complete...", logging.INFO)
+            time.sleep(settling_time)
+            self.logger.log("Next LS settling period complete", logging.INFO)
+        else:
+            error_msg = f"Next LS failed to initialize within {ready_timeout} seconds. This may indicate a problem with the Elixir installation, project compilation, or Next LS itself."
+            self.logger.log(error_msg, logging.ERROR)
+            raise RuntimeError(error_msg)

projects/ui/serena-new/src/solidlsp/language_servers/omnisharp/initialize_params.json

@@ -0,0 +1,631 @@
+{
+    "_description": "The parameters sent by the client when initializing the language server with the \"initialize\" request. More details at https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#initialize",
+    "processId": "os.getpid()",
+    "clientInfo": {
+        "name": "Visual Studio Code - Insiders",
+        "version": "1.82.0-insider"
+    },
+    "locale": "en",
+    "rootPath": "$rootPath",
+    "rootUri": "$rootUri",
+    "capabilities": {
+        "workspace": {
+            "applyEdit": true,
+            "workspaceEdit": {
+                "documentChanges": true,
+                "resourceOperations": [
+                    "create",
+                    "rename",
+                    "delete"
+                ],
+                "failureHandling": "textOnlyTransactional",
+                "normalizesLineEndings": true,
+                "changeAnnotationSupport": {
+                    "groupsOnLabel": true
+                }
+            },
+            "configuration": false,
+            "didChangeWatchedFiles": {
+                "dynamicRegistration": true,
+                "relativePatternSupport": true
+            },
+            "symbol": {
+                "dynamicRegistration": true,
+                "symbolKind": {
+                    "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,
+                        26
+                    ]
+                },
+                "tagSupport": {
+                    "valueSet": [
+                        1
+                    ]
+                },
+                "resolveSupport": {
+                    "properties": [
+                        "location.range"
+                    ]
+                }
+            },
+            "codeLens": {
+                "refreshSupport": true
+            },
+            "executeCommand": {
+                "dynamicRegistration": true
+            },
+            "didChangeConfiguration": {
+                "dynamicRegistration": 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
+            },
+            "completion": {
+                "dynamicRegistration": true,
+                "contextSupport": true,
+                "completionItem": {
+                    "snippetSupport": true,
+                    "commitCharactersSupport": true,
+                    "documentationFormat": [
+                        "markdown",
+                        "plaintext"
+                    ],
+                    "deprecatedSupport": true,
+                    "preselectSupport": true,
+                    "tagSupport": {
+                        "valueSet": [
+                            1
+                        ]
+                    },
+                    "insertReplaceSupport": true,
+                    "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,
+                        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
+                },
+                "contextSupport": true
+            },
+            "definition": {
+                "dynamicRegistration": true,
+                "linkSupport": true
+            },
+            "references": {
+                "dynamicRegistration": true
+            },
+            "documentHighlight": {
+                "dynamicRegistration": true
+            },
+            "documentSymbol": {
+                "dynamicRegistration": true,
+                "symbolKind": {
+                    "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,
+                        26
+                    ]
+                },
+                "hierarchicalDocumentSymbolSupport": true,
+                "tagSupport": {
+                    "valueSet": [
+                        1
+                    ]
+                },
+                "labelSupport": true
+            },
+            "codeAction": {
+                "dynamicRegistration": true,
+                "isPreferredSupport": true,
+                "disabledSupport": true,
+                "dataSupport": true,
+                "resolveSupport": {
+                    "properties": [
+                        "edit"
+                    ]
+                },
+                "codeActionLiteralSupport": {
+                    "codeActionKind": {
+                        "valueSet": [
+                            "",
+                            "quickfix",
+                            "refactor",
+                            "refactor.extract",
+                            "refactor.inline",
+                            "refactor.rewrite",
+                            "source",
+                            "source.organizeImports"
+                        ]
+                    }
+                },
+                "honorsChangeAnnotations": false
+            },
+            "codeLens": {
+                "dynamicRegistration": true
+            },
+            "formatting": {
+                "dynamicRegistration": true
+            },
+            "rangeFormatting": {
+                "dynamicRegistration": true
+            },
+            "onTypeFormatting": {
+                "dynamicRegistration": 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
+            },
+            "foldingRange": {
+                "dynamicRegistration": true,
+                "rangeLimit": 5000,
+                "lineFoldingOnly": true,
+                "foldingRangeKind": {
+                    "valueSet": [
+                        "comment",
+                        "imports",
+                        "region"
+                    ]
+                },
+                "foldingRange": {
+                    "collapsedText": false
+                }
+            },
+            "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": false
+            },
+            "linkedEditingRange": {
+                "dynamicRegistration": true
+            },
+            "typeHierarchy": {
+                "dynamicRegistration": true
+            },
+            "inlineValue": {
+                "dynamicRegistration": true
+            },
+            "inlayHint": {
+                "dynamicRegistration": true,
+                "resolveSupport": {
+                    "properties": [
+                        "tooltip",
+                        "textEdits",
+                        "label.tooltip",
+                        "label.location",
+                        "label.command"
+                    ]
+                }
+            },
+            "diagnostic": {
+                "dynamicRegistration": true,
+                "relatedDocumentSupport": false
+            }
+        },
+        "window": {
+            "showMessage": {
+                "messageActionItem": {
+                    "additionalPropertiesSupport": true
+                }
+            },
+            "showDocument": {
+                "support": true
+            },
+            "workDoneProgress": true
+        },
+        "general": {
+            "staleRequestSupport": {
+                "cancel": true,
+                "retryOnContentModified": [
+                    "textDocument/semanticTokens/full",
+                    "textDocument/semanticTokens/range",
+                    "textDocument/semanticTokens/full/delta"
+                ]
+            },
+            "regularExpressions": {
+                "engine": "ECMAScript",
+                "version": "ES2020"
+            },
+            "markdown": {
+                "parser": "marked",
+                "version": "1.1.0",
+                "allowedTags": [
+                    "ul",
+                    "li",
+                    "p",
+                    "code",
+                    "blockquote",
+                    "ol",
+                    "h1",
+                    "h2",
+                    "h3",
+                    "h4",
+                    "h5",
+                    "h6",
+                    "hr",
+                    "em",
+                    "pre",
+                    "table",
+                    "thead",
+                    "tbody",
+                    "tr",
+                    "th",
+                    "td",
+                    "div",
+                    "del",
+                    "a",
+                    "strong",
+                    "br",
+                    "img",
+                    "span"
+                ]
+            },
+            "positionEncodings": [
+                "utf-16"
+            ]
+        },
+        "notebookDocument": {
+            "synchronization": {
+                "dynamicRegistration": true,
+                "executionSummarySupport": true
+            }
+        },
+        "experimental": {
+            "snippetTextEdit": true,
+            "codeActionGroup": true,
+            "hoverActions": true,
+            "serverStatusNotification": true,
+            "colorDiagnosticOutput": true,
+            "openServerLogs": true,
+            "commands": {
+                "commands": [
+                    "editor.action.triggerParameterHints"
+                ]
+            }
+        }
+    },
+    "initializationOptions": {
+        "RoslynExtensionsOptions": {
+            "EnableDecompilationSupport": false,
+            "EnableAnalyzersSupport": true,
+            "EnableImportCompletion": true,
+            "EnableAsyncCompletion": false,
+            "DocumentAnalysisTimeoutMs": 30000,
+            "DiagnosticWorkersThreadCount": 18,
+            "AnalyzeOpenDocumentsOnly": true,
+            "InlayHintsOptions": {
+                "EnableForParameters": false,
+                "ForLiteralParameters": false,
+                "ForIndexerParameters": false,
+                "ForObjectCreationParameters": false,
+                "ForOtherParameters": false,
+                "SuppressForParametersThatDifferOnlyBySuffix": false,
+                "SuppressForParametersThatMatchMethodIntent": false,
+                "SuppressForParametersThatMatchArgumentName": false,
+                "EnableForTypes": false,
+                "ForImplicitVariableTypes": false,
+                "ForLambdaParameterTypes": false,
+                "ForImplicitObjectCreation": false
+            },
+            "LocationPaths": null
+        },
+        "FormattingOptions": {
+            "OrganizeImports": false,
+            "EnableEditorConfigSupport": true,
+            "NewLine": "\n",
+            "UseTabs": false,
+            "TabSize": 4,
+            "IndentationSize": 4,
+            "SpacingAfterMethodDeclarationName": false,
+            "SeparateImportDirectiveGroups": false,
+            "SpaceWithinMethodDeclarationParenthesis": false,
+            "SpaceBetweenEmptyMethodDeclarationParentheses": false,
+            "SpaceAfterMethodCallName": false,
+            "SpaceWithinMethodCallParentheses": false,
+            "SpaceBetweenEmptyMethodCallParentheses": false,
+            "SpaceAfterControlFlowStatementKeyword": true,
+            "SpaceWithinExpressionParentheses": false,
+            "SpaceWithinCastParentheses": false,
+            "SpaceWithinOtherParentheses": false,
+            "SpaceAfterCast": false,
+            "SpaceBeforeOpenSquareBracket": false,
+            "SpaceBetweenEmptySquareBrackets": false,
+            "SpaceWithinSquareBrackets": false,
+            "SpaceAfterColonInBaseTypeDeclaration": true,
+            "SpaceAfterComma": true,
+            "SpaceAfterDot": false,
+            "SpaceAfterSemicolonsInForStatement": true,
+            "SpaceBeforeColonInBaseTypeDeclaration": true,
+            "SpaceBeforeComma": false,
+            "SpaceBeforeDot": false,
+            "SpaceBeforeSemicolonsInForStatement": false,
+            "SpacingAroundBinaryOperator": "single",
+            "IndentBraces": false,
+            "IndentBlock": true,
+            "IndentSwitchSection": true,
+            "IndentSwitchCaseSection": true,
+            "IndentSwitchCaseSectionWhenBlock": true,
+            "LabelPositioning": "oneLess",
+            "WrappingPreserveSingleLine": true,
+            "WrappingKeepStatementsOnSingleLine": true,
+            "NewLinesForBracesInTypes": true,
+            "NewLinesForBracesInMethods": true,
+            "NewLinesForBracesInProperties": true,
+            "NewLinesForBracesInAccessors": true,
+            "NewLinesForBracesInAnonymousMethods": true,
+            "NewLinesForBracesInControlBlocks": true,
+            "NewLinesForBracesInAnonymousTypes": true,
+            "NewLinesForBracesInObjectCollectionArrayInitializers": true,
+            "NewLinesForBracesInLambdaExpressionBody": true,
+            "NewLineForElse": true,
+            "NewLineForCatch": true,
+            "NewLineForFinally": true,
+            "NewLineForMembersInObjectInit": true,
+            "NewLineForMembersInAnonymousTypes": true,
+            "NewLineForClausesInQuery": true
+        },
+        "FileOptions": {
+            "SystemExcludeSearchPatterns": [
+                "**/node_modules/**/*",
+                "**/bin/**/*",
+                "**/obj/**/*",
+                "**/.git/**/*",
+                "**/.git",
+                "**/.svn",
+                "**/.hg",
+                "**/CVS",
+                "**/.DS_Store",
+                "**/Thumbs.db"
+            ],
+            "ExcludeSearchPatterns": []
+        },
+        "RenameOptions": {
+            "RenameOverloads": false,
+            "RenameInStrings": false,
+            "RenameInComments": false
+        },
+        "ImplementTypeOptions": {
+            "InsertionBehavior": 0,
+            "PropertyGenerationBehavior": 0
+        },
+        "DotNetCliOptions": {
+            "LocationPaths": null
+        },
+        "Plugins": {
+            "LocationPaths": null
+        }
+    },
+    "trace": "verbose",
+    "workspaceFolders": [
+        {
+            "uri": "$uri",
+            "name": "$name"
+        }
+    ]
+}

projects/ui/serena-new/src/solidlsp/language_servers/omnisharp/runtime_dependencies.json

@@ -0,0 +1,441 @@
+{
+    "_description": "Used to download the runtime dependencies for running OmniSharp. Obtained from https://github.com/dotnet/vscode-csharp/blob/main/package.json",
+    "runtimeDependencies": [
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Windows (.NET 4 / x86)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-win-x86-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "x86"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10/OmniSharp.exe",
+            "platformId": "win-x86",
+            "isFramework": true,
+            "integrity": "C81CE2099AD494EF63F9D88FAA70D55A68CF175810F944526FF94AAC7A5109F9",
+            "dotnet_version": "4",
+            "binaryName": "OmniSharp.exe"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Windows (.NET 6 / x86)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-win-x86-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "x86"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "win-x86",
+            "isFramework": false,
+            "integrity": "B7E62415CFC3DAC2154AC636C5BF0FB4B2C9BBF11B5A1FBF72381DDDED59791E",
+            "dotnet_version": "6",
+            "binaryName": "OmniSharp.exe"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Windows (.NET 4 / x64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-win-x64-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10/OmniSharp.exe",
+            "platformId": "win-x64",
+            "isFramework": true,
+            "integrity": "BE0ED10AACEA17E14B78BD0D887DE5935D4ECA3712192A701F3F2100CA3C8B6E",
+            "dotnet_version": "4",
+            "binaryName": "OmniSharp.exe"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Windows (.NET 6 / x64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-win-x64-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "win-x64",
+            "isFramework": false,
+            "integrity": "A73327395E7EF92C1D8E307055463DA412662C03F077ECC743462FD2760BB537",
+            "dotnet_version": "6",
+            "binaryName": "OmniSharp.exe"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Windows (.NET 4 / arm64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-win-arm64-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10/OmniSharp.exe",
+            "platformId": "win-arm64",
+            "isFramework": true,
+            "integrity": "32FA0067B0639F87760CD1A769B16E6A53588C137C4D31661836CA4FB28D3DD6",
+            "dotnet_version": "4",
+            "binaryName": "OmniSharp.exe"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Windows (.NET 6 / arm64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-win-arm64-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "win-arm64",
+            "isFramework": false,
+            "integrity": "433F9B360CAA7B4DDD85C604D5C5542C1A718BCF2E71B2BCFC7526E6D41F4E8F",
+            "dotnet_version": "6",
+            "binaryName": "OmniSharp.exe"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for OSX (Mono / x64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-osx-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10",
+            "platforms": [
+                "darwin"
+            ],
+            "architectures": [
+                "x86_64",
+                "arm64"
+            ],
+            "binaries": [
+                "./mono.osx",
+                "./run"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10/run",
+            "platformId": "osx",
+            "isFramework": true,
+            "integrity": "2CC42F0EC7C30CFA8858501D12ECB6FB685A1FCFB8ECB35698A4B12406551968",
+            "dotnet_version": "mono"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for OSX (.NET 6 / x64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-osx-x64-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "darwin"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "osx-x64",
+            "isFramework": false,
+            "integrity": "C9D6E9F2C839A66A7283AE6A9EC545EE049B48EB230D33E91A6322CB67FF9D97",
+            "dotnet_version": "6"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for OSX (.NET 6 / arm64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-osx-arm64-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "darwin"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "osx-arm64",
+            "isFramework": false,
+            "integrity": "851350F52F83E3BAD5A92D113E4B9882FCD1DEB16AA84FF94B6F2CEE3C70051E",
+            "dotnet_version": "6"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Linux (Mono / x86)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-linux-x86-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10",
+            "platforms": [
+                "linux"
+            ],
+            "architectures": [
+                "x86",
+                "i686"
+            ],
+            "binaries": [
+                "./mono.linux-x86",
+                "./run"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10/run",
+            "platformId": "linux-x86",
+            "isFramework": true,
+            "integrity": "474B1CDBAE64CFEC655FB6B0659BCE481023C48274441C72991E67B6E13E56A1",
+            "dotnet_version": "mono"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Linux (Mono / x64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-linux-x64-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10",
+            "platforms": [
+                "linux"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "binaries": [
+                "./mono.linux-x86_64",
+                "./run"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10/run",
+            "platformId": "linux-x64",
+            "isFramework": true,
+            "integrity": "FB4CAA47343265100349375D79DBCCE1868950CED675CB07FCBE8462EDBCDD37",
+            "dotnet_version": "mono"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Linux (.NET 6 / x64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-linux-x64-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "linux"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "linux-x64",
+            "isFramework": false,
+            "integrity": "0926D3BEA060BF4373356B2FC0A68C10D0DE1B1150100B551BA5932814CE51E2",
+            "dotnet_version": "6",
+            "binaryName": "OmniSharp"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Linux (Mono / arm64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-linux-arm64-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10",
+            "platforms": [
+                "linux"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "binaries": [
+                "./mono.linux-arm64",
+                "./run"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10/run",
+            "platformId": "linux-arm64",
+            "isFramework": true,
+            "integrity": "478F3594DFD0167E9A56E36F0364A86C73F8132A3E7EA916CA1419EFE141D2CC",
+            "dotnet_version": "mono"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Linux (.NET 6 / arm64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-linux-arm64-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "linux"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "linux-arm64",
+            "isFramework": false,
+            "integrity": "6FB6A572043A74220A92F6C19C7BB0C3743321C7563A815FD2702EF4FA7D688E",
+            "dotnet_version": "6"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Linux musl (.NET 6 / x64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-linux-musl-x64-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "linux-musl"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "linux-musl-x64",
+            "isFramework": false,
+            "integrity": "6BFDA3AD11DBB0C6514B86ECC3E1597CC41C6E309B7575F7C599E07D9E2AE610",
+            "dotnet_version": "6"
+        },
+        {
+            "id": "OmniSharp",
+            "description": "OmniSharp for Linux musl (.NET 6 / arm64)",
+            "url": "https://roslynomnisharp.blob.core.windows.net/releases/1.39.10/omnisharp-linux-musl-arm64-net6.0-1.39.10.zip",
+            "installPath": ".omnisharp/1.39.10-net6.0",
+            "platforms": [
+                "linux-musl"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "installTestPath": "./.omnisharp/1.39.10-net6.0/OmniSharp.dll",
+            "platformId": "linux-musl-arm64",
+            "isFramework": false,
+            "integrity": "DA63619EA024EB9BBF6DB5A85C6150CAB5C0BD554544A3596ED1B17F926D6875",
+            "dotnet_version": "6"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (Windows / x64)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/8d42e62ea4051381c219b3e31bc4eced/razorlanguageserver-win-x64-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "platformId": "win-x64",
+            "dll_path": "OmniSharpPlugin/Microsoft.AspNetCore.Razor.OmniSharpPlugin.dll"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (Windows / x86)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/e440c4f3a4a96334fe177513935fa010/razorlanguageserver-win-x86-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "x86"
+            ],
+            "platformId": "win-x86",
+            "dll_path": "OmniSharpPlugin/Microsoft.AspNetCore.Razor.OmniSharpPlugin.dll"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (Windows / ARM64)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/4ef26e45cf32fe8d51c0e7dd21f1fef6/razorlanguageserver-win-arm64-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "win32"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "platformId": "win-arm64",
+            "dll_path": "OmniSharpPlugin/Microsoft.AspNetCore.Razor.OmniSharpPlugin.dll"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (Linux / x64)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/6d4e23a3c7cf0465743950a39515a716/razorlanguageserver-linux-x64-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "linux"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "binaries": [
+                "./rzls"
+            ],
+            "platformId": "linux-x64",
+            "dll_path": "OmniSharpPlugin/Microsoft.AspNetCore.Razor.OmniSharpPlugin.dll"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (Linux ARM64)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/85deebd44647ebf65724cc291d722283/razorlanguageserver-linux-arm64-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "linux"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "binaries": [
+                "./rzls"
+            ],
+            "platformId": "linux-arm64"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (Linux musl / x64)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/4f0caa94ae182785655efb15eafcef23/razorlanguageserver-linux-musl-x64-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "linux-musl"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "binaries": [
+                "./rzls"
+            ],
+            "platformId": "linux-musl-x64"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (Linux musl ARM64)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/0a24828206a6f3b4bc743d058ef88ce7/razorlanguageserver-linux-musl-arm64-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "linux-musl"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "binaries": [
+                "./rzls"
+            ],
+            "platformId": "linux-musl-arm64"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (macOS / x64)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/2afcafaf41082989efcc10405abb9314/razorlanguageserver-osx-x64-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "darwin"
+            ],
+            "architectures": [
+                "x86_64"
+            ],
+            "binaries": [
+                "./rzls"
+            ],
+            "platformId": "osx-x64"
+        },
+        {
+            "id": "RazorOmnisharp",
+            "description": "Razor Language Server for OmniSharp (macOS ARM64)",
+            "url": "https://download.visualstudio.microsoft.com/download/pr/aee63398-023f-48db-bba2-30162c68f0c4/8bf2ed2f00d481a5987e3eb5165afddd/razorlanguageserver-osx-arm64-7.0.0-preview.23363.1.zip",
+            "installPath": ".razoromnisharp",
+            "platforms": [
+                "darwin"
+            ],
+            "architectures": [
+                "arm64"
+            ],
+            "binaries": [
+                "./rzls"
+            ],
+            "platformId": "osx-arm64"
+        }
+    ]
+}

projects/ui/serena-new/src/solidlsp/language_servers/omnisharp/workspace_did_change_configuration.json

@@ -0,0 +1,111 @@
+{
+    "RoslynExtensionsOptions": {
+        "EnableDecompilationSupport": false,
+        "EnableAnalyzersSupport": true,
+        "EnableImportCompletion": true,
+        "EnableAsyncCompletion": false,
+        "DocumentAnalysisTimeoutMs": 30000,
+        "DiagnosticWorkersThreadCount": 18,
+        "AnalyzeOpenDocumentsOnly": true,
+        "InlayHintsOptions": {
+            "EnableForParameters": false,
+            "ForLiteralParameters": false,
+            "ForIndexerParameters": false,
+            "ForObjectCreationParameters": false,
+            "ForOtherParameters": false,
+            "SuppressForParametersThatDifferOnlyBySuffix": false,
+            "SuppressForParametersThatMatchMethodIntent": false,
+            "SuppressForParametersThatMatchArgumentName": false,
+            "EnableForTypes": false,
+            "ForImplicitVariableTypes": false,
+            "ForLambdaParameterTypes": false,
+            "ForImplicitObjectCreation": false
+        },
+        "LocationPaths": null
+    },
+    "FormattingOptions": {
+        "OrganizeImports": false,
+        "EnableEditorConfigSupport": true,
+        "NewLine": "\n",
+        "UseTabs": false,
+        "TabSize": 4,
+        "IndentationSize": 4,
+        "SpacingAfterMethodDeclarationName": false,
+        "SeparateImportDirectiveGroups": false,
+        "SpaceWithinMethodDeclarationParenthesis": false,
+        "SpaceBetweenEmptyMethodDeclarationParentheses": false,
+        "SpaceAfterMethodCallName": false,
+        "SpaceWithinMethodCallParentheses": false,
+        "SpaceBetweenEmptyMethodCallParentheses": false,
+        "SpaceAfterControlFlowStatementKeyword": true,
+        "SpaceWithinExpressionParentheses": false,
+        "SpaceWithinCastParentheses": false,
+        "SpaceWithinOtherParentheses": false,
+        "SpaceAfterCast": false,
+        "SpaceBeforeOpenSquareBracket": false,
+        "SpaceBetweenEmptySquareBrackets": false,
+        "SpaceWithinSquareBrackets": false,
+        "SpaceAfterColonInBaseTypeDeclaration": true,
+        "SpaceAfterComma": true,
+        "SpaceAfterDot": false,
+        "SpaceAfterSemicolonsInForStatement": true,
+        "SpaceBeforeColonInBaseTypeDeclaration": true,
+        "SpaceBeforeComma": false,
+        "SpaceBeforeDot": false,
+        "SpaceBeforeSemicolonsInForStatement": false,
+        "SpacingAroundBinaryOperator": "single",
+        "IndentBraces": false,
+        "IndentBlock": true,
+        "IndentSwitchSection": true,
+        "IndentSwitchCaseSection": true,
+        "IndentSwitchCaseSectionWhenBlock": true,
+        "LabelPositioning": "oneLess",
+        "WrappingPreserveSingleLine": true,
+        "WrappingKeepStatementsOnSingleLine": true,
+        "NewLinesForBracesInTypes": true,
+        "NewLinesForBracesInMethods": true,
+        "NewLinesForBracesInProperties": true,
+        "NewLinesForBracesInAccessors": true,
+        "NewLinesForBracesInAnonymousMethods": true,
+        "NewLinesForBracesInControlBlocks": true,
+        "NewLinesForBracesInAnonymousTypes": true,
+        "NewLinesForBracesInObjectCollectionArrayInitializers": true,
+        "NewLinesForBracesInLambdaExpressionBody": true,
+        "NewLineForElse": true,
+        "NewLineForCatch": true,
+        "NewLineForFinally": true,
+        "NewLineForMembersInObjectInit": true,
+        "NewLineForMembersInAnonymousTypes": true,
+        "NewLineForClausesInQuery": true
+    },
+    "FileOptions": {
+        "SystemExcludeSearchPatterns": [
+            "**/node_modules/**/*",
+            "**/bin/**/*",
+            "**/obj/**/*",
+            "**/.git/**/*",
+            "**/.git",
+            "**/.svn",
+            "**/.hg",
+            "**/CVS",
+            "**/.DS_Store",
+            "**/Thumbs.db"
+        ],
+        "ExcludeSearchPatterns": []
+    },
+    "RenameOptions": {
+        "RenameOverloads": false,
+        "RenameInStrings": false,
+        "RenameInComments": false
+    },
+    "ImplementTypeOptions": {
+        "InsertionBehavior": 0,
+        "PropertyGenerationBehavior": 0
+    },
+    "DotNetCliOptions": {
+        "LocationPaths": null
+    },
+    "Plugins": {
+        "LocationPaths": null
+    }
+}

projects/ui/serena-new/src/solidlsp/util/subprocess_util.py

@@ -0,0 +1,13 @@
+import platform
+import subprocess
+
+
+def subprocess_kwargs():
+    """
+    Returns a dictionary of keyword arguments for subprocess calls, adding platform-specific
+    flags that we want to use consistently.
+    """
+    kwargs = {}
+    if platform.system() == "Windows":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW  # type: ignore
+    return kwargs

projects/ui/serena-new/src/solidlsp/util/zip.py

@@ -0,0 +1,128 @@
+import fnmatch
+import logging
+import os
+import sys
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+log = logging.getLogger(__name__)
+
+
+class SafeZipExtractor:
+    """
+    A utility class for extracting ZIP archives safely.
+
+    Features:
+    - Handles long file paths on Windows
+    - Skips files that fail to extract, continuing with the rest
+    - Creates necessary directories automatically
+    - Optional include/exclude pattern filters
+    """
+
+    def __init__(
+        self,
+        archive_path: Path,
+        extract_dir: Path,
+        verbose: bool = True,
+        include_patterns: Optional[list[str]] = None,
+        exclude_patterns: Optional[list[str]] = None,
+    ) -> None:
+        """
+        Initialize the SafeZipExtractor.
+
+        :param archive_path: Path to the ZIP archive file
+        :param extract_dir: Directory where files will be extracted
+        :param verbose: Whether to log status messages
+        :param include_patterns: List of glob patterns for files to extract (None = all files)
+        :param exclude_patterns: List of glob patterns for files to skip
+        """
+        self.archive_path = Path(archive_path)
+        self.extract_dir = Path(extract_dir)
+        self.verbose = verbose
+        self.include_patterns = include_patterns or []
+        self.exclude_patterns = exclude_patterns or []
+
+    def extract_all(self) -> None:
+        """
+        Extract all files from the archive, skipping any that fail.
+        """
+        if not self.archive_path.exists():
+            raise FileNotFoundError(f"Archive not found: {self.archive_path}")
+
+        if self.verbose:
+            log.info(f"Extracting from: {self.archive_path} to {self.extract_dir}")
+
+        with zipfile.ZipFile(self.archive_path, "r") as zip_ref:
+            for member in zip_ref.infolist():
+                if self._should_extract(member.filename):
+                    self._extract_member(zip_ref, member)
+                elif self.verbose:
+                    log.info(f"Skipped: {member.filename}")
+
+    def _should_extract(self, filename: str) -> bool:
+        """
+        Determine whether a file should be extracted based on include/exclude patterns.
+
+        :param filename: The file name from the archive
+        :return: True if the file should be extracted
+        """
+        # If include_patterns is set, only extract if it matches at least one pattern
+        if self.include_patterns:
+            if not any(fnmatch.fnmatch(filename, pattern) for pattern in self.include_patterns):
+                return False
+
+        # If exclude_patterns is set, skip if it matches any pattern
+        if self.exclude_patterns:
+            if any(fnmatch.fnmatch(filename, pattern) for pattern in self.exclude_patterns):
+                return False
+
+        return True
+
+    def _extract_member(self, zip_ref: zipfile.ZipFile, member: zipfile.ZipInfo) -> None:
+        """
+        Extract a single member from the archive with error handling.
+
+        :param zip_ref: Open ZipFile object
+        :param member: ZipInfo object representing the file
+        """
+        try:
+            target_path = self.extract_dir / member.filename
+
+            # Ensure directory structure exists
+            target_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Handle long paths on Windows
+            final_path = self._normalize_path(target_path)
+
+            # Extract file
+            with zip_ref.open(member) as source, open(final_path, "wb") as target:
+                target.write(source.read())
+
+            if self.verbose:
+                log.info(f"Extracted: {member.filename}")
+
+        except Exception as e:
+            log.error(f"Failed to extract {member.filename}: {e}")
+
+    @staticmethod
+    def _normalize_path(path: Path) -> Path:
+        """
+        Adjust path to handle long paths on Windows.
+
+        :param path: Original path
+        :return: Normalized path
+        """
+        if sys.platform.startswith("win"):
+            return Path(rf"\\?\{os.path.abspath(path)}")
+        return path
+
+
+# Example usage:
+# extractor = SafeZipExtractor(
+#     archive_path=Path("file.nupkg"),
+#     extract_dir=Path("extract_dir"),
+#     include_patterns=["*.dll", "*.xml"],
+#     exclude_patterns=["*.pdb"]
+# )
+# extractor.extract_all()

projects/ui/serena-new/test/resources/repos/bash/test_repo/config.sh

@@ -0,0 +1,91 @@
+#!/bin/bash
+
+# Configuration script for project setup
+
+# Environment variables
+export PROJECT_NAME="bash-test-project"
+export PROJECT_VERSION="1.0.0"
+export LOG_LEVEL="INFO"
+export CONFIG_DIR="./config"
+
+# Default settings
+DEFAULT_TIMEOUT=30
+DEFAULT_RETRIES=3
+DEFAULT_PORT=8080
+
+# Configuration arrays
+declare -A ENVIRONMENTS=(
+    ["dev"]="development"
+    ["prod"]="production"
+    ["test"]="testing"
+)
+
+declare -A DATABASE_CONFIGS=(
+    ["host"]="localhost"
+    ["port"]="5432"
+    ["name"]="myapp_db"
+    ["user"]="dbuser"
+)
+
+# Function to load configuration
+load_config() {
+    local env="${1:-dev}"
+    local config_file="${CONFIG_DIR}/${env}.conf"
+    
+    if [[ -f "$config_file" ]]; then
+        echo "Loading configuration from $config_file"
+        source "$config_file"
+    else
+        echo "Warning: Configuration file $config_file not found, using defaults"
+    fi
+}
+
+# Function to validate configuration
+validate_config() {
+    local errors=0
+    
+    if [[ -z "$PROJECT_NAME" ]]; then
+        echo "Error: PROJECT_NAME is not set" >&2
+        ((errors++))
+    fi
+    
+    if [[ -z "$PROJECT_VERSION" ]]; then
+        echo "Error: PROJECT_VERSION is not set" >&2
+        ((errors++))
+    fi
+    
+    if [[ $DEFAULT_PORT -lt 1024 || $DEFAULT_PORT -gt 65535 ]]; then
+        echo "Error: Invalid port number $DEFAULT_PORT" >&2
+        ((errors++))
+    fi
+    
+    return $errors
+}
+
+# Function to print configuration
+print_config() {
+    echo "=== Current Configuration ==="
+    echo "Project Name: $PROJECT_NAME"
+    echo "Version: $PROJECT_VERSION"
+    echo "Log Level: $LOG_LEVEL"
+    echo "Default Port: $DEFAULT_PORT"
+    echo "Default Timeout: $DEFAULT_TIMEOUT"
+    echo "Default Retries: $DEFAULT_RETRIES"
+    
+    echo "\n=== Environments ==="
+    for env in "${!ENVIRONMENTS[@]}"; do
+        echo "  $env: ${ENVIRONMENTS[$env]}"
+    done
+    
+    echo "\n=== Database Configuration ==="
+    for key in "${!DATABASE_CONFIGS[@]}"; do
+        echo "  $key: ${DATABASE_CONFIGS[$key]}"
+    done
+}
+
+# Initialize configuration if this script is run directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    load_config "$1"
+    validate_config
+    print_config
+fi

projects/ui/serena-new/test/resources/repos/bash/test_repo/main.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+# Main script demonstrating various bash features
+
+# Global variables
+readonly SCRIPT_NAME="Main Script"
+COUNTER=0
+declare -a ITEMS=("item1" "item2" "item3")
+
+# Function definitions
+function greet_user() {
+    local username="$1"
+    local greeting_type="${2:-default}"
+    
+    case "$greeting_type" in
+        "formal")
+            echo "Good day, ${username}!"
+            ;;
+        "casual")
+            echo "Hey ${username}!"
+            ;;
+        *)
+            echo "Hello, ${username}!"
+            ;;
+    esac
+}
+
+function process_items() {
+    local -n items_ref=$1
+    local operation="$2"
+    
+    for item in "${items_ref[@]}"; do
+        case "$operation" in
+            "count")
+                ((COUNTER++))
+                echo "Processing item $COUNTER: $item"
+                ;;
+            "uppercase")
+                echo "${item^^}"
+                ;;
+            *)
+                echo "Unknown operation: $operation"
+                return 1
+                ;;
+        esac
+    done
+}
+
+# Main execution
+main() {
+    echo "Starting $SCRIPT_NAME"
+    
+    if [[ $# -eq 0 ]]; then
+        echo "Usage: $0 <username> [greeting_type]"
+        exit 1
+    fi
+    
+    local user="$1"
+    local greeting="${2:-default}"
+    
+    greet_user "$user" "$greeting"
+    
+    echo "Processing items..."
+    process_items ITEMS "count"
+    
+    echo "Script completed successfully"
+}
+
+# Run main function with all arguments
+main "$@"

projects/ui/serena-new/test/resources/repos/bash/test_repo/utils.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+
+# Utility functions for bash scripting
+
+# String manipulation functions
+function to_uppercase() {
+    echo "${1^^}"
+}
+
+function to_lowercase() {
+    echo "${1,,}"
+}
+
+function trim_whitespace() {
+    local var="$1"
+    var="${var#"${var%%[![:space:]]*}"}"
+    var="${var%"${var##*[![:space:]]}"}"   
+    echo "$var"
+}
+
+# File operations
+function backup_file() {
+    local file="$1"
+    local backup_dir="${2:-./backups}"
+    
+    if [[ ! -f "$file" ]]; then
+        echo "Error: File '$file' does not exist" >&2
+        return 1
+    fi
+    
+    mkdir -p "$backup_dir"
+    cp "$file" "${backup_dir}/$(basename "$file").$(date +%Y%m%d_%H%M%S).bak"
+    echo "Backup created for $file"
+}
+
+# Array operations
+function contains_element() {
+    local element="$1"
+    shift
+    local array=("$@")
+    
+    for item in "${array[@]}"; do
+        if [[ "$item" == "$element" ]]; then
+            return 0
+        fi
+    done
+    return 1
+}
+
+# Logging functions
+function log_message() {
+    local level="$1"
+    local message="$2"
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    
+    case "$level" in
+        "ERROR")
+            echo "[$timestamp] ERROR: $message" >&2
+            ;;
+        "WARN")
+            echo "[$timestamp] WARN: $message" >&2
+            ;;
+        "INFO")
+            echo "[$timestamp] INFO: $message"
+            ;;
+        "DEBUG")
+            [[ "${DEBUG:-false}" == "true" ]] && echo "[$timestamp] DEBUG: $message"
+            ;;
+        *)
+            echo "[$timestamp] $message"
+            ;;
+    esac
+}
+
+# Validation functions
+function is_valid_email() {
+    local email="$1"
+    [[ "$email" =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]
+}
+
+function is_number() {
+    [[ $1 =~ ^[0-9]+$ ]]
+}

projects/ui/serena-new/test/resources/repos/clojure/test_repo/deps.edn

@@ -0,0 +1,5 @@
+{:paths ["src"]
+ :deps {org.clojure/clojure {:mvn/version "1.11.1"}}
+ :aliases
+ {:test {:extra-paths ["test"]
+         :extra-deps {org.clojure/test.check {:mvn/version "1.1.1"}}}}}

projects/ui/serena-new/test/serena/__init__.py

@@ -0,0 +1 @@
+

projects/ui/serena-new/test/serena/test_edit_marker.py

@@ -0,0 +1,13 @@
+from serena.tools import CreateTextFileTool, ReadFileTool, Tool
+
+
+class TestEditMarker:
+    def test_tool_can_edit_method(self):
+        """Test that Tool.can_edit() method works correctly"""
+        # Non-editing tool should return False
+        assert issubclass(ReadFileTool, Tool)
+        assert not ReadFileTool.can_edit()
+
+        # Editing tool should return True
+        assert issubclass(CreateTextFileTool, Tool)
+        assert CreateTextFileTool.can_edit()

projects/ui/serena-new/test/serena/test_mcp.py

@@ -0,0 +1,300 @@
+"""Tests for the mcp.py module in serena."""
+
+import pytest
+from mcp.server.fastmcp.tools.base import Tool as MCPTool
+
+from serena.agent import Tool, ToolRegistry
+from serena.config.context_mode import SerenaAgentContext
+from serena.mcp import SerenaMCPFactory
+
+make_tool = SerenaMCPFactory.make_mcp_tool
+
+
+# Create a mock agent for tool initialization
+class MockAgent:
+    def __init__(self):
+        self.project_config = None
+        self.serena_config = None
+
+    @staticmethod
+    def get_context() -> SerenaAgentContext:
+        return SerenaAgentContext.load_default()
+
+
+class BaseMockTool(Tool):
+    """A mock Tool class for testing."""
+
+    def __init__(self):
+        super().__init__(MockAgent())  # type: ignore
+
+
+class BasicTool(BaseMockTool):
+    """A mock Tool class for testing."""
+
+    def apply(self, name: str, age: int = 0) -> str:
+        """This is a test function.
+
+        :param name: The person's name
+        :param age: The person's age
+        :return: A greeting message
+        """
+        return f"Hello {name}, you are {age} years old!"
+
+    def apply_ex(
+        self,
+        log_call: bool = True,
+        catch_exceptions: bool = True,
+        **kwargs,
+    ) -> str:
+        """Mock implementation of apply_ex."""
+        return self.apply(**kwargs)
+
+
+def test_make_tool_basic() -> None:
+    """Test that make_tool correctly creates an MCP tool from a Tool object."""
+    mock_tool = BasicTool()
+
+    mcp_tool = make_tool(mock_tool)
+
+    # Test that the MCP tool has the correct properties
+    assert isinstance(mcp_tool, MCPTool)
+    assert mcp_tool.name == "basic"
+    assert "This is a test function. Returns A greeting message." in mcp_tool.description
+
+    # Test that the parameters were correctly processed
+    parameters = mcp_tool.parameters
+    assert "properties" in parameters
+    assert "name" in parameters["properties"]
+    assert "age" in parameters["properties"]
+    assert parameters["properties"]["name"]["description"] == "The person's name."
+    assert parameters["properties"]["age"]["description"] == "The person's age."
+
+
+def test_make_tool_execution() -> None:
+    """Test that the execution function created by make_tool works correctly."""
+    mock_tool = BasicTool()
+    mcp_tool = make_tool(mock_tool)
+
+    # Execute the MCP tool function
+    result = mcp_tool.fn(name="Alice", age=30)
+
+    assert result == "Hello Alice, you are 30 years old!"
+
+
+def test_make_tool_no_params() -> None:
+    """Test make_tool with a function that has no parameters."""
+
+    class NoParamsTool(BaseMockTool):
+        def apply(self) -> str:
+            """This is a test function with no parameters.
+
+            :return: A simple result
+            """
+            return "Simple result"
+
+        def apply_ex(self, *args, **kwargs) -> str:
+            return self.apply()
+
+    tool = NoParamsTool()
+    mcp_tool = make_tool(tool)
+
+    assert mcp_tool.name == "no_params"
+    assert "This is a test function with no parameters. Returns A simple result." in mcp_tool.description
+    assert mcp_tool.parameters["properties"] == {}
+
+
+def test_make_tool_no_return_description() -> None:
+    """Test make_tool with a function that has no return description."""
+
+    class NoReturnTool(BaseMockTool):
+        def apply(self, param: str) -> str:
+            """This is a test function.
+
+            :param param: The parameter
+            """
+            return f"Processed: {param}"
+
+        def apply_ex(self, *args, **kwargs) -> str:
+            return self.apply(**kwargs)
+
+    tool = NoReturnTool()
+    mcp_tool = make_tool(tool)
+
+    assert mcp_tool.name == "no_return"
+    assert mcp_tool.description == "This is a test function."
+    assert mcp_tool.parameters["properties"]["param"]["description"] == "The parameter."
+
+
+def test_make_tool_parameter_not_in_docstring() -> None:
+    """Test make_tool when a parameter in properties is not in the docstring."""
+
+    class MissingParamTool(BaseMockTool):
+        def apply(self, name: str, missing_param: str = "") -> str:
+            """This is a test function.
+
+            :param name: The person's name
+            """
+            return f"Hello {name}! Missing param: {missing_param}"
+
+        def apply_ex(self, *args, **kwargs) -> str:
+            return self.apply(**kwargs)
+
+    tool = MissingParamTool()
+    mcp_tool = make_tool(tool)
+
+    assert "name" in mcp_tool.parameters["properties"]
+    assert "missing_param" in mcp_tool.parameters["properties"]
+    assert mcp_tool.parameters["properties"]["name"]["description"] == "The person's name."
+    assert "description" not in mcp_tool.parameters["properties"]["missing_param"]
+
+
+def test_make_tool_multiline_docstring() -> None:
+    """Test make_tool with a complex multi-line docstring."""
+
+    class ComplexDocTool(BaseMockTool):
+        def apply(self, project_file_path: str, host: str, port: int) -> str:
+            """Create an MCP server.
+
+            This function creates and configures a Model Context Protocol server
+            with the specified settings.
+
+            :param project_file_path: The path to the project file, or None
+            :param host: The host to bind to
+            :param port: The port to bind to
+            :return: A configured FastMCP server instance
+            """
+            return f"Server config: {project_file_path}, {host}:{port}"
+
+        def apply_ex(self, *args, **kwargs) -> str:
+            return self.apply(**kwargs)
+
+    tool = ComplexDocTool()
+    mcp_tool = make_tool(tool)
+
+    assert "Create an MCP server" in mcp_tool.description
+    assert "Returns A configured FastMCP server instance" in mcp_tool.description
+    assert mcp_tool.parameters["properties"]["project_file_path"]["description"] == "The path to the project file, or None."
+    assert mcp_tool.parameters["properties"]["host"]["description"] == "The host to bind to."
+    assert mcp_tool.parameters["properties"]["port"]["description"] == "The port to bind to."
+
+
+def test_make_tool_capitalization_and_periods() -> None:
+    """Test that make_tool properly handles capitalization and periods in descriptions."""
+
+    class FormatTool(BaseMockTool):
+        def apply(self, param1: str, param2: str, param3: str) -> str:
+            """Test function.
+
+            :param param1: lowercase description
+            :param param2: description with period.
+            :param param3: description with Capitalized word.
+            """
+            return f"Formatted: {param1}, {param2}, {param3}"
+
+        def apply_ex(self, *args, **kwargs) -> str:
+            return self.apply(**kwargs)
+
+    tool = FormatTool()
+    mcp_tool = make_tool(tool)
+
+    assert mcp_tool.parameters["properties"]["param1"]["description"] == "Lowercase description."
+    assert mcp_tool.parameters["properties"]["param2"]["description"] == "Description with period."
+    assert mcp_tool.parameters["properties"]["param3"]["description"] == "Description with Capitalized word."
+
+
+def test_make_tool_missing_apply() -> None:
+    """Test make_tool with a tool that doesn't have an apply method."""
+
+    class BadTool(BaseMockTool):
+        pass
+
+    tool = BadTool()
+
+    with pytest.raises(AttributeError):
+        make_tool(tool)
+
+
+@pytest.mark.parametrize(
+    "docstring, expected_description",
+    [
+        (
+            """This is a test function.
+
+            :param param: The parameter
+            :return: A result
+            """,
+            "This is a test function. Returns A result.",
+        ),
+        (
+            """
+            :param param: The parameter
+            :return: A result
+            """,
+            "Returns A result.",
+        ),
+        (
+            """
+            :param param: The parameter
+            """,
+            "",
+        ),
+        ("Description without params.", "Description without params."),
+    ],
+)
+def test_make_tool_descriptions(docstring, expected_description) -> None:
+    """Test make_tool with various docstring formats."""
+
+    class TestTool(BaseMockTool):
+        def apply(self, param: str) -> str:
+            return f"Result: {param}"
+
+        def apply_ex(self, *args, **kwargs) -> str:
+            return self.apply(**kwargs)
+
+    # Dynamically set the docstring
+    TestTool.apply.__doc__ = docstring
+
+    tool = TestTool()
+    mcp_tool = make_tool(tool)
+
+    assert mcp_tool.name == "test"
+    assert mcp_tool.description == expected_description
+
+
+def is_test_mock_class(tool_class: type) -> bool:
+    """Check if a class is a test mock class."""
+    # Check if the class is defined in a test module
+    module_name = tool_class.__module__
+    return (
+        module_name.startswith(("test.", "tests."))
+        or "test_" in module_name
+        or tool_class.__name__
+        in [
+            "BaseMockTool",
+            "BasicTool",
+            "BadTool",
+            "NoParamsTool",
+            "NoReturnTool",
+            "MissingParamTool",
+            "ComplexDocTool",
+            "FormatTool",
+            "NoDescriptionTool",
+        ]
+    )
+
+
+@pytest.mark.parametrize("tool_class", ToolRegistry().get_all_tool_classes())
+def test_make_tool_all_tools(tool_class) -> None:
+    """Test that make_tool works for all tools in the codebase."""
+    # Create an instance of the tool
+    tool_instance = tool_class(MockAgent())
+
+    # Try to create an MCP tool from it
+    mcp_tool = make_tool(tool_instance)
+
+    # Basic validation
+    assert isinstance(mcp_tool, MCPTool)
+    assert mcp_tool.name == tool_class.get_name_from_cls()
+
+    # The description should be a string (either from docstring or default)
+    assert isinstance(mcp_tool.description, str)

projects/ui/serena-new/test/serena/test_serena_agent.py

@@ -0,0 +1,286 @@
+import json
+import logging
+import os
+import time
+
+import pytest
+
+import test.solidlsp.clojure as clj
+from serena.agent import SerenaAgent
+from serena.config.serena_config import ProjectConfig, RegisteredProject, SerenaConfig
+from serena.project import Project
+from serena.tools import FindReferencingSymbolsTool, FindSymbolTool
+from solidlsp.ls_config import Language
+from test.conftest import get_repo_path
+
+
+@pytest.fixture
+def serena_config():
+    """Create an in-memory configuration for tests with test repositories pre-registered."""
+    # Create test projects for all supported languages
+    test_projects = []
+    for language in [
+        Language.PYTHON,
+        Language.GO,
+        Language.JAVA,
+        Language.KOTLIN,
+        Language.RUST,
+        Language.TYPESCRIPT,
+        Language.PHP,
+        Language.CSHARP,
+        Language.CLOJURE,
+    ]:
+        repo_path = get_repo_path(language)
+        if repo_path.exists():
+            project_name = f"test_repo_{language}"
+            project = Project(
+                project_root=str(repo_path),
+                project_config=ProjectConfig(
+                    project_name=project_name,
+                    language=language,
+                    ignored_paths=[],
+                    excluded_tools=set(),
+                    read_only=False,
+                    ignore_all_files_in_gitignore=True,
+                    initial_prompt="",
+                    encoding="utf-8",
+                ),
+            )
+            test_projects.append(RegisteredProject.from_project_instance(project))
+
+    config = SerenaConfig(gui_log_window_enabled=False, web_dashboard=False, log_level=logging.ERROR)
+    config.projects = test_projects
+    return config
+
+
+@pytest.fixture
+def serena_agent(request: pytest.FixtureRequest, serena_config):
+    language = Language(request.param)
+    project_name = f"test_repo_{language}"
+
+    return SerenaAgent(project=project_name, serena_config=serena_config)
+
+
+class TestSerenaAgent:
+    @pytest.mark.parametrize(
+        "serena_agent,symbol_name,expected_kind,expected_file",
+        [
+            pytest.param(Language.PYTHON, "User", "Class", "models.py", marks=pytest.mark.python),
+            pytest.param(Language.GO, "Helper", "Function", "main.go", marks=pytest.mark.go),
+            pytest.param(Language.JAVA, "Model", "Class", "Model.java", marks=pytest.mark.java),
+            pytest.param(Language.KOTLIN, "Model", "Struct", "Model.kt", marks=pytest.mark.kotlin),
+            pytest.param(Language.RUST, "add", "Function", "lib.rs", marks=pytest.mark.rust),
+            pytest.param(Language.TYPESCRIPT, "DemoClass", "Class", "index.ts", marks=pytest.mark.typescript),
+            pytest.param(Language.PHP, "helperFunction", "Function", "helper.php", marks=pytest.mark.php),
+            pytest.param(
+                Language.CLOJURE,
+                "greet",
+                "Function",
+                clj.CORE_PATH,
+                marks=[pytest.mark.clojure, pytest.mark.skipif(clj.CLI_FAIL, reason=f"Clojure CLI not available: {clj.CLI_FAIL}")],
+            ),
+            pytest.param(Language.CSHARP, "Calculator", "Class", "Program.cs", marks=pytest.mark.csharp),
+        ],
+        indirect=["serena_agent"],
+    )
+    def test_find_symbol(self, serena_agent, symbol_name: str, expected_kind: str, expected_file: str):
+        agent = serena_agent
+        find_symbol_tool = agent.get_tool(FindSymbolTool)
+        result = find_symbol_tool.apply_ex(name_path=symbol_name)
+
+        symbols = json.loads(result)
+        assert any(
+            symbol_name in s["name_path"] and expected_kind.lower() in s["kind"].lower() and expected_file in s["relative_path"]
+            for s in symbols
+        ), f"Expected to find {symbol_name} ({expected_kind}) in {expected_file}"
+
+    @pytest.mark.parametrize(
+        "serena_agent,symbol_name,def_file,ref_file",
+        [
+            pytest.param(
+                Language.PYTHON,
+                "User",
+                os.path.join("test_repo", "models.py"),
+                os.path.join("test_repo", "services.py"),
+                marks=pytest.mark.python,
+            ),
+            pytest.param(Language.GO, "Helper", "main.go", "main.go", marks=pytest.mark.go),
+            pytest.param(
+                Language.JAVA,
+                "Model",
+                os.path.join("src", "main", "java", "test_repo", "Model.java"),
+                os.path.join("src", "main", "java", "test_repo", "Main.java"),
+                marks=pytest.mark.java,
+            ),
+            pytest.param(
+                Language.KOTLIN,
+                "Model",
+                os.path.join("src", "main", "kotlin", "test_repo", "Model.kt"),
+                os.path.join("src", "main", "kotlin", "test_repo", "Main.kt"),
+                marks=pytest.mark.kotlin,
+            ),
+            pytest.param(Language.RUST, "add", os.path.join("src", "lib.rs"), os.path.join("src", "main.rs"), marks=pytest.mark.rust),
+            pytest.param(Language.TYPESCRIPT, "helperFunction", "index.ts", "use_helper.ts", marks=pytest.mark.typescript),
+            pytest.param(Language.PHP, "helperFunction", "helper.php", "index.php", marks=pytest.mark.php),
+            pytest.param(
+                Language.CLOJURE,
+                "multiply",
+                clj.CORE_PATH,
+                clj.UTILS_PATH,
+                marks=[pytest.mark.clojure, pytest.mark.skipif(clj.CLI_FAIL, reason=f"Clojure CLI not available: {clj.CLI_FAIL}")],
+            ),
+            pytest.param(Language.CSHARP, "Calculator", "Program.cs", "Program.cs", marks=pytest.mark.csharp),
+        ],
+        indirect=["serena_agent"],
+    )
+    def test_find_symbol_references(self, serena_agent, symbol_name: str, def_file: str, ref_file: str) -> None:
+        agent = serena_agent
+
+        # Find the symbol location first
+        find_symbol_tool = agent.get_tool(FindSymbolTool)
+        result = find_symbol_tool.apply_ex(name_path=symbol_name, relative_path=def_file)
+
+        time.sleep(1)
+        symbols = json.loads(result)
+        # Find the definition
+        def_symbol = symbols[0]
+
+        # Now find references
+        find_refs_tool = agent.get_tool(FindReferencingSymbolsTool)
+        result = find_refs_tool.apply_ex(name_path=def_symbol["name_path"], relative_path=def_symbol["relative_path"])
+
+        refs = json.loads(result)
+        assert any(
+            ref["relative_path"] == ref_file for ref in refs
+        ), f"Expected to find reference to {symbol_name} in {ref_file}. refs={refs}"
+
+    @pytest.mark.parametrize(
+        "serena_agent,name_path,substring_matching,expected_symbol_name,expected_kind,expected_file",
+        [
+            pytest.param(
+                Language.PYTHON,
+                "OuterClass/NestedClass",
+                False,
+                "NestedClass",
+                "Class",
+                os.path.join("test_repo", "nested.py"),
+                id="exact_qualname_class",
+                marks=pytest.mark.python,
+            ),
+            pytest.param(
+                Language.PYTHON,
+                "OuterClass/NestedClass/find_me",
+                False,
+                "find_me",
+                "Method",
+                os.path.join("test_repo", "nested.py"),
+                id="exact_qualname_method",
+                marks=pytest.mark.python,
+            ),
+            pytest.param(
+                Language.PYTHON,
+                "OuterClass/NestedCl",  # Substring for NestedClass
+                True,
+                "NestedClass",
+                "Class",
+                os.path.join("test_repo", "nested.py"),
+                id="substring_qualname_class",
+                marks=pytest.mark.python,
+            ),
+            pytest.param(
+                Language.PYTHON,
+                "OuterClass/NestedClass/find_m",  # Substring for find_me
+                True,
+                "find_me",
+                "Method",
+                os.path.join("test_repo", "nested.py"),
+                id="substring_qualname_method",
+                marks=pytest.mark.python,
+            ),
+            pytest.param(
+                Language.PYTHON,
+                "/OuterClass",  # Absolute path
+                False,
+                "OuterClass",
+                "Class",
+                os.path.join("test_repo", "nested.py"),
+                id="absolute_qualname_class",
+                marks=pytest.mark.python,
+            ),
+            pytest.param(
+                Language.PYTHON,
+                "/OuterClass/NestedClass/find_m",  # Absolute path with substring
+                True,
+                "find_me",
+                "Method",
+                os.path.join("test_repo", "nested.py"),
+                id="absolute_substring_qualname_method",
+                marks=pytest.mark.python,
+            ),
+        ],
+        indirect=["serena_agent"],
+    )
+    def test_find_symbol_name_path(
+        self,
+        serena_agent,
+        name_path: str,
+        substring_matching: bool,
+        expected_symbol_name: str,
+        expected_kind: str,
+        expected_file: str,
+    ):
+        agent = serena_agent
+
+        find_symbol_tool = agent.get_tool(FindSymbolTool)
+        result = find_symbol_tool.apply_ex(
+            name_path=name_path,
+            depth=0,
+            relative_path=None,
+            include_body=False,
+            include_kinds=None,
+            exclude_kinds=None,
+            substring_matching=substring_matching,
+        )
+
+        symbols = json.loads(result)
+        assert any(
+            expected_symbol_name == s["name_path"].split("/")[-1]
+            and expected_kind.lower() in s["kind"].lower()
+            and expected_file in s["relative_path"]
+            for s in symbols
+        ), f"Expected to find {name_path} ({expected_kind}) in {expected_file} for {agent._active_project.language.name}. Symbols: {symbols}"
+
+    @pytest.mark.parametrize(
+        "serena_agent,name_path",
+        [
+            pytest.param(
+                Language.PYTHON,
+                "/NestedClass",  # Absolute path, NestedClass is not top-level
+                id="absolute_path_non_top_level_no_match",
+                marks=pytest.mark.python,
+            ),
+            pytest.param(
+                Language.PYTHON,
+                "/NoSuchParent/NestedClass",  # Absolute path with non-existent parent
+                id="absolute_path_non_existent_parent_no_match",
+                marks=pytest.mark.python,
+            ),
+        ],
+        indirect=["serena_agent"],
+    )
+    def test_find_symbol_name_path_no_match(
+        self,
+        serena_agent,
+        name_path: str,
+    ):
+        agent = serena_agent
+
+        find_symbol_tool = agent.get_tool(FindSymbolTool)
+        result = find_symbol_tool.apply_ex(
+            name_path=name_path,
+            depth=0,
+            substring_matching=True,
+        )
+
+        symbols = json.loads(result)
+        assert not symbols, f"Expected to find no symbols for {name_path}. Symbols found: {symbols}"

projects/ui/serena-new/test/serena/test_symbol.py

@@ -0,0 +1,162 @@
+import pytest
+
+from src.serena.symbol import LanguageServerSymbol
+
+
+class TestSymbolNameMatching:
+    def _create_assertion_error_message(
+        self,
+        name_path_pattern: str,
+        symbol_name_path_parts: list[str],
+        is_substring_match: bool,
+        expected_result: bool,
+        actual_result: bool,
+    ) -> str:
+        """Helper to create a detailed error message for assertions."""
+        qnp_repr = "/".join(symbol_name_path_parts)
+
+        return (
+            f"Pattern '{name_path_pattern}' (substring: {is_substring_match}) vs "
+            f"Qualname parts {symbol_name_path_parts} (as '{qnp_repr}'). "
+            f"Expected: {expected_result}, Got: {actual_result}"
+        )
+
+    @pytest.mark.parametrize(
+        "name_path_pattern, symbol_name_path_parts, is_substring_match, expected",
+        [
+            # Exact matches, anywhere in the name (is_substring_match=False)
+            pytest.param("foo", ["foo"], False, True, id="'foo' matches 'foo' exactly (simple)"),
+            pytest.param("foo/", ["foo"], False, True, id="'foo/' matches 'foo' exactly (simple)"),
+            pytest.param("foo", ["bar", "foo"], False, True, id="'foo' matches ['bar', 'foo'] exactly (simple, last element)"),
+            pytest.param("foo", ["foobar"], False, False, id="'foo' does not match 'foobar' exactly (simple)"),
+            pytest.param(
+                "foo", ["bar", "foobar"], False, False, id="'foo' does not match ['bar', 'foobar'] exactly (simple, last element)"
+            ),
+            pytest.param(
+                "foo", ["path", "to", "foo"], False, True, id="'foo' matches ['path', 'to', 'foo'] exactly (simple, last element)"
+            ),
+            # Exact matches, absolute patterns (is_substring_match=False)
+            pytest.param("/foo", ["foo"], False, True, id="'/foo' matches ['foo'] exactly (absolute simple)"),
+            pytest.param("/foo", ["foo", "bar"], False, False, id="'/foo' does not match ['foo', 'bar'] (absolute simple, len mismatch)"),
+            pytest.param("/foo", ["bar"], False, False, id="'/foo' does not match ['bar'] (absolute simple, name mismatch)"),
+            pytest.param(
+                "/foo", ["bar", "foo"], False, False, id="'/foo' does not match ['bar', 'foo'] (absolute simple, position mismatch)"
+            ),
+            # Substring matches, anywhere in the name (is_substring_match=True)
+            pytest.param("foo", ["foobar"], True, True, id="'foo' matches 'foobar' as substring (simple)"),
+            pytest.param("foo", ["bar", "foobar"], True, True, id="'foo' matches ['bar', 'foobar'] as substring (simple, last element)"),
+            pytest.param(
+                "foo", ["barfoo"], True, True, id="'foo' matches 'barfoo' as substring (simple)"
+            ),  # This was potentially ambiguous before
+            pytest.param("foo", ["baz"], True, False, id="'foo' does not match 'baz' as substring (simple)"),
+            pytest.param("foo", ["bar", "baz"], True, False, id="'foo' does not match ['bar', 'baz'] as substring (simple, last element)"),
+            pytest.param("foo", ["my_foobar_func"], True, True, id="'foo' matches 'my_foobar_func' as substring (simple)"),
+            pytest.param(
+                "foo",
+                ["ClassA", "my_foobar_method"],
+                True,
+                True,
+                id="'foo' matches ['ClassA', 'my_foobar_method'] as substring (simple, last element)",
+            ),
+            pytest.param("foo", ["my_bar_func"], True, False, id="'foo' does not match 'my_bar_func' as substring (simple)"),
+            # Substring matches, absolute patterns (is_substring_match=True)
+            pytest.param("/foo", ["foobar"], True, True, id="'/foo' matches ['foobar'] as substring (absolute simple)"),
+            pytest.param("/foo/", ["foobar"], True, True, id="'/foo/' matches ['foobar'] as substring (absolute simple, last element)"),
+            pytest.param("/foo", ["barfoobaz"], True, True, id="'/foo' matches ['barfoobaz'] as substring (absolute simple)"),
+            pytest.param(
+                "/foo", ["foo", "bar"], True, False, id="'/foo' does not match ['foo', 'bar'] as substring (absolute simple, len mismatch)"
+            ),
+            pytest.param("/foo", ["bar"], True, False, id="'/foo' does not match ['bar'] (absolute simple, no substr)"),
+            pytest.param(
+                "/foo", ["bar", "foo"], True, False, id="'/foo' does not match ['bar', 'foo'] (absolute simple, position mismatch)"
+            ),
+            pytest.param(
+                "/foo/", ["bar", "foo"], True, False, id="'/foo/' does not match ['bar', 'foo'] (absolute simple, position mismatch)"
+            ),
+        ],
+    )
+    def test_match_simple_name(self, name_path_pattern, symbol_name_path_parts, is_substring_match, expected):
+        """Tests matching for simple names (no '/' in pattern)."""
+        result = LanguageServerSymbol.match_name_path(name_path_pattern, symbol_name_path_parts, is_substring_match)
+        error_msg = self._create_assertion_error_message(name_path_pattern, symbol_name_path_parts, is_substring_match, expected, result)
+        assert result == expected, error_msg
+
+    @pytest.mark.parametrize(
+        "name_path_pattern, symbol_name_path_parts, is_substring_match, expected",
+        [
+            # --- Relative patterns (suffix matching) ---
+            # Exact matches, relative patterns (is_substring_match=False)
+            pytest.param("bar/foo", ["bar", "foo"], False, True, id="R: 'bar/foo' matches ['bar', 'foo'] exactly"),
+            pytest.param("bar/foo", ["mod", "bar", "foo"], False, True, id="R: 'bar/foo' matches ['mod', 'bar', 'foo'] exactly (suffix)"),
+            pytest.param(
+                "bar/foo", ["bar", "foo", "baz"], False, False, id="R: 'bar/foo' does not match ['bar', 'foo', 'baz'] (pattern shorter)"
+            ),
+            pytest.param("bar/foo", ["bar"], False, False, id="R: 'bar/foo' does not match ['bar'] (pattern longer)"),
+            pytest.param("bar/foo", ["baz", "foo"], False, False, id="R: 'bar/foo' does not match ['baz', 'foo'] (first part mismatch)"),
+            pytest.param("bar/foo", ["bar", "baz"], False, False, id="R: 'bar/foo' does not match ['bar', 'baz'] (last part mismatch)"),
+            pytest.param("bar/foo", ["foo"], False, False, id="R: 'bar/foo' does not match ['foo'] (pattern longer)"),
+            pytest.param(
+                "bar/foo", ["other", "foo"], False, False, id="R: 'bar/foo' does not match ['other', 'foo'] (first part mismatch)"
+            ),
+            pytest.param(
+                "bar/foo", ["bar", "otherfoo"], False, False, id="R: 'bar/foo' does not match ['bar', 'otherfoo'] (last part mismatch)"
+            ),
+            # Substring matches, relative patterns (is_substring_match=True)
+            pytest.param("bar/foo", ["bar", "foobar"], True, True, id="R: 'bar/foo' matches ['bar', 'foobar'] as substring"),
+            pytest.param(
+                "bar/foo", ["mod", "bar", "foobar"], True, True, id="R: 'bar/foo' matches ['mod', 'bar', 'foobar'] as substring (suffix)"
+            ),
+            pytest.param("bar/foo", ["bar", "bazfoo"], True, True, id="R: 'bar/foo' matches ['bar', 'bazfoo'] as substring"),
+            pytest.param("bar/fo", ["bar", "foo"], True, True, id="R: 'bar/fo' matches ['bar', 'foo'] as substring"),  # codespell:ignore
+            pytest.param("bar/foo", ["bar", "baz"], True, False, id="R: 'bar/foo' does not match ['bar', 'baz'] (last no substr)"),
+            pytest.param(
+                "bar/foo", ["baz", "foobar"], True, False, id="R: 'bar/foo' does not match ['baz', 'foobar'] (first part mismatch)"
+            ),
+            pytest.param(
+                "bar/foo", ["bar", "my_foobar_method"], True, True, id="R: 'bar/foo' matches ['bar', 'my_foobar_method'] as substring"
+            ),
+            pytest.param(
+                "bar/foo",
+                ["mod", "bar", "my_foobar_method"],
+                True,
+                True,
+                id="R: 'bar/foo' matches ['mod', 'bar', 'my_foobar_method'] as substring (suffix)",
+            ),
+            pytest.param(
+                "bar/foo",
+                ["bar", "another_method"],
+                True,
+                False,
+                id="R: 'bar/foo' does not match ['bar', 'another_method'] (last no substr)",
+            ),
+            pytest.param(
+                "bar/foo",
+                ["other", "my_foobar_method"],
+                True,
+                False,
+                id="R: 'bar/foo' does not match ['other', 'my_foobar_method'] (first part mismatch)",
+            ),
+            pytest.param("bar/f", ["bar", "foo"], True, True, id="R: 'bar/f' matches ['bar', 'foo'] as substring"),
+            # Exact matches, absolute patterns (is_substring_match=False)
+            pytest.param("/bar/foo", ["bar", "foo"], False, True, id="A: '/bar/foo' matches ['bar', 'foo'] exactly"),
+            pytest.param(
+                "/bar/foo", ["bar", "foo", "baz"], False, False, id="A: '/bar/foo' does not match ['bar', 'foo', 'baz'] (pattern shorter)"
+            ),
+            pytest.param("/bar/foo", ["bar"], False, False, id="A: '/bar/foo' does not match ['bar'] (pattern longer)"),
+            pytest.param("/bar/foo", ["baz", "foo"], False, False, id="A: '/bar/foo' does not match ['baz', 'foo'] (first part mismatch)"),
+            pytest.param("/bar/foo", ["bar", "baz"], False, False, id="A: '/bar/foo' does not match ['bar', 'baz'] (last part mismatch)"),
+            # Substring matches (is_substring_match=True)
+            pytest.param("/bar/foo", ["bar", "foobar"], True, True, id="A: '/bar/foo' matches ['bar', 'foobar'] as substring"),
+            pytest.param("/bar/foo", ["bar", "bazfoo"], True, True, id="A: '/bar/foo' matches ['bar', 'bazfoo'] as substring"),
+            pytest.param("/bar/fo", ["bar", "foo"], True, True, id="A: '/bar/fo' matches ['bar', 'foo'] as substring"),  # codespell:ignore
+            pytest.param("/bar/foo", ["bar", "baz"], True, False, id="A: '/bar/foo' does not match ['bar', 'baz'] (last no substr)"),
+            pytest.param(
+                "/bar/foo", ["baz", "foobar"], True, False, id="A: '/bar/foo' does not match ['baz', 'foobar'] (first part mismatch)"
+            ),
+        ],
+    )
+    def test_match_name_path_pattern_path_len_2(self, name_path_pattern, symbol_name_path_parts, is_substring_match, expected):
+        """Tests matching for qualified names (e.g. 'module/class/func')."""
+        result = LanguageServerSymbol.match_name_path(name_path_pattern, symbol_name_path_parts, is_substring_match)
+        error_msg = self._create_assertion_error_message(name_path_pattern, symbol_name_path_parts, is_substring_match, expected, result)
+        assert result == expected, error_msg

projects/ui/serena-new/test/serena/test_symbol_editing.py

@@ -0,0 +1,485 @@
+import logging
+import os
+import shutil
+import sys
+import tempfile
+import time
+from abc import abstractmethod
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from difflib import SequenceMatcher
+from pathlib import Path
+from typing import Literal, NamedTuple
+
+import pytest
+
+from serena.code_editor import CodeEditor, LanguageServerCodeEditor
+from solidlsp.ls_config import Language
+from src.serena.symbol import LanguageServerSymbolRetriever
+from test.conftest import create_ls, get_repo_path
+
+pytestmark = pytest.mark.snapshot
+
+log = logging.getLogger(__name__)
+
+
+class LineChange(NamedTuple):
+    """Represents a change to a specific line or range of lines."""
+
+    operation: Literal["insert", "delete", "replace"]
+    original_start: int
+    original_end: int
+    modified_start: int
+    modified_end: int
+    original_lines: list[str]
+    modified_lines: list[str]
+
+
+@dataclass
+class CodeDiff:
+    """
+    Represents the difference between original and modified code.
+    Provides object-oriented access to diff information including line numbers.
+    """
+
+    relative_path: str
+    original_content: str
+    modified_content: str
+    _line_changes: list[LineChange] = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Compute the diff using difflib's SequenceMatcher."""
+        original_lines = self.original_content.splitlines(keepends=True)
+        modified_lines = self.modified_content.splitlines(keepends=True)
+
+        matcher = SequenceMatcher(None, original_lines, modified_lines)
+        self._line_changes = []
+
+        for tag, orig_start, orig_end, mod_start, mod_end in matcher.get_opcodes():
+            if tag == "equal":
+                continue
+            if tag == "insert":
+                self._line_changes.append(
+                    LineChange(
+                        operation="insert",
+                        original_start=orig_start,
+                        original_end=orig_start,
+                        modified_start=mod_start,
+                        modified_end=mod_end,
+                        original_lines=[],
+                        modified_lines=modified_lines[mod_start:mod_end],
+                    )
+                )
+            elif tag == "delete":
+                self._line_changes.append(
+                    LineChange(
+                        operation="delete",
+                        original_start=orig_start,
+                        original_end=orig_end,
+                        modified_start=mod_start,
+                        modified_end=mod_start,
+                        original_lines=original_lines[orig_start:orig_end],
+                        modified_lines=[],
+                    )
+                )
+            elif tag == "replace":
+                self._line_changes.append(
+                    LineChange(
+                        operation="replace",
+                        original_start=orig_start,
+                        original_end=orig_end,
+                        modified_start=mod_start,
+                        modified_end=mod_end,
+                        original_lines=original_lines[orig_start:orig_end],
+                        modified_lines=modified_lines[mod_start:mod_end],
+                    )
+                )
+
+    @property
+    def line_changes(self) -> list[LineChange]:
+        """Get all line changes in the diff."""
+        return self._line_changes
+
+    @property
+    def has_changes(self) -> bool:
+        """Check if there are any changes."""
+        return len(self._line_changes) > 0
+
+    @property
+    def added_lines(self) -> list[tuple[int, str]]:
+        """Get all added lines with their line numbers (0-based) in the modified file."""
+        result = []
+        for change in self._line_changes:
+            if change.operation in ("insert", "replace"):
+                for i, line in enumerate(change.modified_lines):
+                    result.append((change.modified_start + i, line))
+        return result
+
+    @property
+    def deleted_lines(self) -> list[tuple[int, str]]:
+        """Get all deleted lines with their line numbers (0-based) in the original file."""
+        result = []
+        for change in self._line_changes:
+            if change.operation in ("delete", "replace"):
+                for i, line in enumerate(change.original_lines):
+                    result.append((change.original_start + i, line))
+        return result
+
+    @property
+    def modified_line_numbers(self) -> list[int]:
+        """Get all line numbers (0-based) that were modified in the modified file."""
+        line_nums: set[int] = set()
+        for change in self._line_changes:
+            if change.operation in ("insert", "replace"):
+                line_nums.update(range(change.modified_start, change.modified_end))
+        return sorted(line_nums)
+
+    @property
+    def affected_original_line_numbers(self) -> list[int]:
+        """Get all line numbers (0-based) that were affected in the original file."""
+        line_nums: set[int] = set()
+        for change in self._line_changes:
+            if change.operation in ("delete", "replace"):
+                line_nums.update(range(change.original_start, change.original_end))
+        return sorted(line_nums)
+
+    def get_unified_diff(self, context_lines: int = 3) -> str:
+        """Get the unified diff as a string."""
+        import difflib
+
+        original_lines = self.original_content.splitlines(keepends=True)
+        modified_lines = self.modified_content.splitlines(keepends=True)
+
+        diff = difflib.unified_diff(
+            original_lines, modified_lines, fromfile=f"a/{self.relative_path}", tofile=f"b/{self.relative_path}", n=context_lines
+        )
+        return "".join(diff)
+
+    def get_context_diff(self, context_lines: int = 3) -> str:
+        """Get the context diff as a string."""
+        import difflib
+
+        original_lines = self.original_content.splitlines(keepends=True)
+        modified_lines = self.modified_content.splitlines(keepends=True)
+
+        diff = difflib.context_diff(
+            original_lines, modified_lines, fromfile=f"a/{self.relative_path}", tofile=f"b/{self.relative_path}", n=context_lines
+        )
+        return "".join(diff)
+
+
+class EditingTest:
+    def __init__(self, language: Language, rel_path: str):
+        """
+        :param language: the language
+        :param rel_path: the relative path of the edited file
+        """
+        self.rel_path = rel_path
+        self.language = language
+        self.original_repo_path = get_repo_path(language)
+        self.repo_path: Path | None = None
+
+    @contextmanager
+    def _setup(self) -> Iterator[LanguageServerSymbolRetriever]:
+        """Context manager for setup/teardown with a temporary directory, providing the symbol manager."""
+        temp_dir = Path(tempfile.mkdtemp())
+        self.repo_path = temp_dir / self.original_repo_path.name
+        language_server = None  # Initialize language_server
+        try:
+            print(f"Copying repo from {self.original_repo_path} to {self.repo_path}")
+            shutil.copytree(self.original_repo_path, self.repo_path)
+            # prevent deadlock on Windows due to file locks caused by antivirus or some other external software
+            # wait for a long time here
+            if os.name == "nt":
+                time.sleep(0.1)
+            log.info(f"Creating language server for {self.language} {self.rel_path}")
+            language_server = create_ls(self.language, str(self.repo_path))
+            log.info(f"Starting language server for {self.language} {self.rel_path}")
+            language_server.start()
+            log.info(f"Language server started for {self.language} {self.rel_path}")
+            yield LanguageServerSymbolRetriever(lang_server=language_server)
+        finally:
+            if language_server is not None and language_server.is_running():
+                log.info(f"Stopping language server for {self.language} {self.rel_path}")
+                language_server.stop()
+                # attempt at trigger of garbage collection
+                language_server = None
+                log.info(f"Language server stopped for {self.language} {self.rel_path}")
+
+            # prevent deadlock on Windows due to lingering file locks
+            if os.name == "nt":
+                time.sleep(0.1)
+            log.info(f"Removing temp directory {temp_dir}")
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            log.info(f"Temp directory {temp_dir} removed")
+
+    def _read_file(self, rel_path: str) -> str:
+        """Read the content of a file in the test repository."""
+        assert self.repo_path is not None
+        file_path = self.repo_path / rel_path
+        with open(file_path, encoding="utf-8") as f:
+            return f.read()
+
+    def run_test(self, content_after_ground_truth: str) -> None:
+        with self._setup() as symbol_retriever:
+            content_before = self._read_file(self.rel_path)
+            code_editor = LanguageServerCodeEditor(symbol_retriever)
+            self._apply_edit(code_editor)
+            content_after = self._read_file(self.rel_path)
+            code_diff = CodeDiff(self.rel_path, original_content=content_before, modified_content=content_after)
+            self._test_diff(code_diff, content_after_ground_truth)
+
+    @abstractmethod
+    def _apply_edit(self, code_editor: CodeEditor) -> None:
+        pass
+
+    def _test_diff(self, code_diff: CodeDiff, snapshot: str) -> None:
+        assert code_diff.modified_content == snapshot
+
+
+# Python test file path
+PYTHON_TEST_REL_FILE_PATH = os.path.join("test_repo", "variables.py")
+
+# TypeScript test file path
+TYPESCRIPT_TEST_FILE = "index.ts"
+
+
+class DeleteSymbolTest(EditingTest):
+    def __init__(self, language: Language, rel_path: str, deleted_symbol: str):
+        super().__init__(language, rel_path)
+        self.deleted_symbol = deleted_symbol
+        self.rel_path = rel_path
+
+    def _apply_edit(self, code_editor: CodeEditor) -> None:
+        code_editor.delete_symbol(self.deleted_symbol, self.rel_path)
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        pytest.param(
+            DeleteSymbolTest(
+                Language.PYTHON,
+                PYTHON_TEST_REL_FILE_PATH,
+                "VariableContainer",
+            ),
+            marks=pytest.mark.python,
+        ),
+        pytest.param(
+            DeleteSymbolTest(
+                Language.TYPESCRIPT,
+                TYPESCRIPT_TEST_FILE,
+                "DemoClass",
+            ),
+            marks=pytest.mark.typescript,
+        ),
+    ],
+)
+def test_delete_symbol(test_case, snapshot):
+    test_case.run_test(content_after_ground_truth=snapshot)
+
+
+NEW_PYTHON_FUNCTION = """def new_inserted_function():
+    print("This is a new function inserted before another.")"""
+
+NEW_PYTHON_CLASS_WITH_LEADING_NEWLINES = """
+
+class NewInsertedClass:
+    pass
+"""
+
+NEW_PYTHON_CLASS_WITH_TRAILING_NEWLINES = """class NewInsertedClass:
+    pass
+
+
+"""
+
+NEW_TYPESCRIPT_FUNCTION = """function newInsertedFunction(): void {
+    console.log("This is a new function inserted before another.");
+}"""
+
+
+NEW_PYTHON_VARIABLE = 'new_module_var = "Inserted after typed_module_var"'
+
+NEW_TYPESCRIPT_FUNCTION_AFTER = """function newFunctionAfterClass(): void {
+    console.log("This function is after DemoClass.");
+}"""
+
+
+class InsertInRelToSymbolTest(EditingTest):
+    def __init__(
+        self, language: Language, rel_path: str, symbol_name: str, new_content: str, mode: Literal["before", "after"] | None = None
+    ):
+        super().__init__(language, rel_path)
+        self.symbol_name = symbol_name
+        self.new_content = new_content
+        self.mode: Literal["before", "after"] | None = mode
+
+    def set_mode(self, mode: Literal["before", "after"]):
+        self.mode = mode
+
+    def _apply_edit(self, code_editor: CodeEditor) -> None:
+        assert self.mode is not None
+        if self.mode == "before":
+            code_editor.insert_before_symbol(self.symbol_name, self.rel_path, self.new_content)
+        elif self.mode == "after":
+            code_editor.insert_after_symbol(self.symbol_name, self.rel_path, self.new_content)
+
+
+@pytest.mark.parametrize("mode", ["before", "after"])
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        pytest.param(
+            InsertInRelToSymbolTest(
+                Language.PYTHON,
+                PYTHON_TEST_REL_FILE_PATH,
+                "typed_module_var",
+                NEW_PYTHON_VARIABLE,
+            ),
+            marks=pytest.mark.python,
+        ),
+        pytest.param(
+            InsertInRelToSymbolTest(
+                Language.PYTHON,
+                PYTHON_TEST_REL_FILE_PATH,
+                "use_module_variables",
+                NEW_PYTHON_FUNCTION,
+            ),
+            marks=pytest.mark.python,
+        ),
+        pytest.param(
+            InsertInRelToSymbolTest(
+                Language.TYPESCRIPT,
+                TYPESCRIPT_TEST_FILE,
+                "DemoClass",
+                NEW_TYPESCRIPT_FUNCTION_AFTER,
+            ),
+            marks=pytest.mark.typescript,
+        ),
+        pytest.param(
+            InsertInRelToSymbolTest(
+                Language.TYPESCRIPT,
+                TYPESCRIPT_TEST_FILE,
+                "helperFunction",
+                NEW_TYPESCRIPT_FUNCTION,
+            ),
+            marks=pytest.mark.typescript,
+        ),
+    ],
+)
+def test_insert_in_rel_to_symbol(test_case: InsertInRelToSymbolTest, mode: Literal["before", "after"], snapshot):
+    test_case.set_mode(mode)
+    test_case.run_test(content_after_ground_truth=snapshot)
+
+
+@pytest.mark.python
+def test_insert_python_class_before(snapshot):
+    InsertInRelToSymbolTest(
+        Language.PYTHON,
+        PYTHON_TEST_REL_FILE_PATH,
+        "VariableDataclass",
+        NEW_PYTHON_CLASS_WITH_TRAILING_NEWLINES,
+        mode="before",
+    ).run_test(snapshot)
+
+
+@pytest.mark.python
+def test_insert_python_class_after(snapshot):
+    InsertInRelToSymbolTest(
+        Language.PYTHON,
+        PYTHON_TEST_REL_FILE_PATH,
+        "VariableDataclass",
+        NEW_PYTHON_CLASS_WITH_LEADING_NEWLINES,
+        mode="after",
+    ).run_test(snapshot)
+
+
+PYTHON_REPLACED_BODY = """def modify_instance_var(self):
+        # This body has been replaced
+        self.instance_var = "Replaced!"
+        self.reassignable_instance_var = 999
+"""
+
+TYPESCRIPT_REPLACED_BODY = """function printValue() {
+        // This body has been replaced
+        console.warn("New value: " + this.value);
+    }
+"""
+
+
+class ReplaceBodyTest(EditingTest):
+    def __init__(self, language: Language, rel_path: str, symbol_name: str, new_body: str):
+        super().__init__(language, rel_path)
+        self.symbol_name = symbol_name
+        self.new_body = new_body
+
+    def _apply_edit(self, code_editor: CodeEditor) -> None:
+        code_editor.replace_body(self.symbol_name, self.rel_path, self.new_body)
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        pytest.param(
+            ReplaceBodyTest(
+                Language.PYTHON,
+                PYTHON_TEST_REL_FILE_PATH,
+                "VariableContainer/modify_instance_var",
+                PYTHON_REPLACED_BODY,
+            ),
+            marks=pytest.mark.python,
+        ),
+        pytest.param(
+            ReplaceBodyTest(
+                Language.TYPESCRIPT,
+                TYPESCRIPT_TEST_FILE,
+                "DemoClass/printValue",
+                TYPESCRIPT_REPLACED_BODY,
+            ),
+            marks=pytest.mark.typescript,
+        ),
+    ],
+)
+def test_replace_body(test_case: ReplaceBodyTest, snapshot):
+    test_case.run_test(content_after_ground_truth=snapshot)
+
+
+NIX_ATTR_REPLACEMENT = """c = 3;"""
+
+
+class NixAttrReplacementTest(EditingTest):
+    """Test for replacing individual attributes in Nix that should NOT result in double semicolons."""
+
+    def __init__(self, language: Language, rel_path: str, symbol_name: str, new_body: str):
+        super().__init__(language, rel_path)
+        self.symbol_name = symbol_name
+        self.new_body = new_body
+
+    def _apply_edit(self, code_editor: CodeEditor) -> None:
+        code_editor.replace_body(self.symbol_name, self.rel_path, self.new_body)
+
+
+@pytest.mark.nix
+@pytest.mark.skipif(sys.platform == "win32", reason="nixd language server doesn't run on Windows")
+def test_nix_symbol_replacement_no_double_semicolon(snapshot):
+    """
+    Test that replacing a Nix attribute does not result in double semicolons.
+
+    This test exercises the bug where:
+    - Original: users.users.example = { isSystemUser = true; group = "example"; description = "Example service user"; };
+    - Replacement: c = 3;
+    - Bug result would be: c = 3;; (double semicolon)
+    - Correct result should be: c = 3; (single semicolon)
+
+    The replacement body includes a semicolon, but the language server's range extension
+    logic should prevent double semicolons.
+    """
+    test_case = NixAttrReplacementTest(
+        Language.NIX,
+        "default.nix",
+        "testUser",  # Simple attrset with multiple key-value pairs
+        NIX_ATTR_REPLACEMENT,
+    )
+    test_case.run_test(content_after_ground_truth=snapshot)

projects/ui/serena-new/test/serena/test_text_utils.py

@@ -0,0 +1,484 @@
+import re
+
+import pytest
+
+from serena.text_utils import LineType, search_files, search_text
+
+
+class TestSearchText:
+    def test_search_text_with_string_pattern(self):
+        """Test searching with a simple string pattern."""
+        content = """
+        def hello_world():
+            print("Hello, World!")
+            return 42
+        """
+
+        # Search for a simple string pattern
+        matches = search_text("print", content=content)
+
+        assert len(matches) == 1
+        assert matches[0].num_matched_lines == 1
+        assert matches[0].start_line == 3
+        assert matches[0].end_line == 3
+        assert matches[0].lines[0].line_content.strip() == 'print("Hello, World!")'
+
+    def test_search_text_with_regex_pattern(self):
+        """Test searching with a regex pattern."""
+        content = """
+        class DataProcessor:
+            def __init__(self, data):
+                self.data = data
+
+            def process(self):
+                return [x * 2 for x in self.data if x > 0]
+
+            def filter(self, predicate):
+                return [x for x in self.data if predicate(x)]
+        """
+
+        # Search for a regex pattern matching method definitions
+        pattern = r"def\s+\w+\s*\([^)]*\):"
+        matches = search_text(pattern, content=content)
+
+        assert len(matches) == 3
+        assert matches[0].lines[0].match_type == LineType.MATCH
+        assert "def __init__" in matches[0].lines[0].line_content
+        assert "def process" in matches[1].lines[0].line_content
+        assert "def filter" in matches[2].lines[0].line_content
+
+    def test_search_text_with_compiled_regex(self):
+        """Test searching with a pre-compiled regex pattern."""
+        content = """
+        import os
+        import sys
+        from pathlib import Path
+
+        # Configuration variables
+        DEBUG = True
+        MAX_RETRIES = 3
+
+        def configure_logging():
+            log_level = "DEBUG" if DEBUG else "INFO"
+            print(f"Setting log level to {log_level}")
+        """
+
+        # Search for variable assignments with a compiled regex
+        pattern = re.compile(r"^\s*[A-Z_]+ = .+$")
+        matches = search_text(pattern, content=content)
+
+        assert len(matches) == 2
+        assert "DEBUG = True" in matches[0].lines[0].line_content
+        assert "MAX_RETRIES = 3" in matches[1].lines[0].line_content
+
+    def test_search_text_with_context_lines(self):
+        """Test searching with context lines before and after the match."""
+        content = """
+        def complex_function(a, b, c):
+            # This is a complex function that does something.
+            if a > b:
+                return a * c
+            elif b > a:
+                return b * c
+            else:
+                return (a + b) * c
+        """
+
+        # Search with context lines
+        matches = search_text("return", content=content, context_lines_before=1, context_lines_after=1)
+
+        assert len(matches) == 3
+
+        # Check the first match with context
+        first_match = matches[0]
+        assert len(first_match.lines) == 3
+        assert first_match.lines[0].match_type == LineType.BEFORE_MATCH
+        assert first_match.lines[1].match_type == LineType.MATCH
+        assert first_match.lines[2].match_type == LineType.AFTER_MATCH
+
+        # Verify the content of lines
+        assert "if a > b:" in first_match.lines[0].line_content
+        assert "return a * c" in first_match.lines[1].line_content
+        assert "elif b > a:" in first_match.lines[2].line_content
+
+    def test_search_text_with_multiline_match(self):
+        """Test searching with multiline pattern matching."""
+        content = """
+        def factorial(n):
+            if n <= 1:
+                return 1
+            else:
+                return n * factorial(n-1)
+
+        result = factorial(5)  # Should be 120
+        """
+
+        # Search for a pattern that spans multiple lines (if-else block)
+        pattern = r"if.*?else.*?return"
+        matches = search_text(pattern, content=content, allow_multiline_match=True)
+
+        assert len(matches) == 1
+        multiline_match = matches[0]
+        assert multiline_match.num_matched_lines >= 3
+        assert "if n <= 1:" in multiline_match.lines[0].line_content
+
+        # All matched lines should have match_type == LineType.MATCH
+        match_lines = [line for line in multiline_match.lines if line.match_type == LineType.MATCH]
+        assert len(match_lines) >= 3
+
+    def test_search_text_with_glob_pattern(self):
+        """Test searching with glob-like patterns."""
+        content = """
+        class UserService:
+            def get_user(self, user_id):
+                return {"id": user_id, "name": "Test User"}
+
+            def create_user(self, user_data):
+                print(f"Creating user: {user_data}")
+                return {"id": 123, **user_data}
+
+            def update_user(self, user_id, user_data):
+                print(f"Updating user {user_id} with {user_data}")
+                return True
+        """
+
+        # Search with a glob pattern for all user methods
+        matches = search_text("*_user*", content=content, is_glob=True)
+
+        assert len(matches) == 3
+        assert "get_user" in matches[0].lines[0].line_content
+        assert "create_user" in matches[1].lines[0].line_content
+        assert "update_user" in matches[2].lines[0].line_content
+
+    def test_search_text_with_complex_glob_pattern(self):
+        """Test searching with more complex glob patterns."""
+        content = """
+        def process_data(data):
+            return [transform(item) for item in data]
+
+        def transform(item):
+            if isinstance(item, dict):
+                return {k: v.upper() if isinstance(v, str) else v for k, v in item.items()}
+            elif isinstance(item, list):
+                return [x * 2 for x in item if isinstance(x, (int, float))]
+            elif isinstance(item, str):
+                return item.upper()
+            else:
+                return item
+        """
+
+        # Search with a simplified glob pattern to find all isinstance occurrences
+        matches = search_text("*isinstance*", content=content, is_glob=True)
+
+        # Should match lines with isinstance(item, dict) and isinstance(item, list)
+        assert len(matches) >= 2
+        instance_matches = [
+            line.line_content
+            for match in matches
+            for line in match.lines
+            if line.match_type == LineType.MATCH and "isinstance(item," in line.line_content
+        ]
+        assert len(instance_matches) >= 2
+        assert any("isinstance(item, dict)" in line for line in instance_matches)
+        assert any("isinstance(item, list)" in line for line in instance_matches)
+
+    def test_search_text_glob_with_special_chars(self):
+        """Glob patterns containing regex special characters should match literally."""
+        content = """
+        def func_square():
+            print("value[42]")
+
+        def func_curly():
+            print("value{bar}")
+        """
+
+        matches_square = search_text(r"*\[42\]*", content=content, is_glob=True)
+        assert len(matches_square) == 1
+        assert "[42]" in matches_square[0].lines[0].line_content
+
+        matches_curly = search_text("*{bar}*", content=content, is_glob=True)
+        assert len(matches_curly) == 1
+        assert "{bar}" in matches_curly[0].lines[0].line_content
+
+    def test_search_text_no_matches(self):
+        """Test searching with a pattern that doesn't match anything."""
+        content = """
+        def calculate_average(numbers):
+            if not numbers:
+                return 0
+            return sum(numbers) / len(numbers)
+        """
+
+        # Search for a pattern that doesn't exist in the content
+        matches = search_text("missing_function", content=content)
+
+        assert len(matches) == 0
+
+
+# Mock file reader that always returns matching content
+def mock_reader_always_match(file_path: str) -> str:
+    """Mock file reader that returns content guaranteed to match the simple pattern."""
+    return "This line contains a match."
+
+
+class TestSearchFiles:
+    @pytest.mark.parametrize(
+        "file_paths, pattern, paths_include_glob, paths_exclude_glob, expected_matched_files, description",
+        [
+            # Basic cases
+            (["a.py", "b.txt"], "match", None, None, ["a.py", "b.txt"], "No filters"),
+            (["a.py", "b.txt"], "match", "*.py", None, ["a.py"], "Include only .py files"),
+            (["a.py", "b.txt"], "match", None, "*.txt", ["a.py"], "Exclude .txt files"),
+            (["a.py", "b.txt", "c.py"], "match", "*.py", "c.*", ["a.py"], "Include .py, exclude c.*"),
+            # Directory matching - Using pathspec patterns
+            (["main.c", "test/main.c"], "match", "test/*", None, ["test/main.c"], "Include files in test/ subdir"),
+            (["data/a.csv", "data/b.log"], "match", "data/*", "*.log", ["data/a.csv"], "Include data/*, exclude *.log"),
+            (["src/a.py", "tests/b.py"], "match", "src/**", "tests/**", ["src/a.py"], "Include src/**, exclude tests/**"),
+            (["src/mod/a.py", "tests/b.py"], "match", "**/*.py", "tests/**", ["src/mod/a.py"], "Include **/*.py, exclude tests/**"),
+            (["file.py", "dir/file.py"], "match", "dir/*.py", None, ["dir/file.py"], "Include files directly in dir"),
+            (["file.py", "dir/sub/file.py"], "match", "dir/**/*.py", None, ["dir/sub/file.py"], "Include files recursively in dir"),
+            # Overlap and edge cases
+            (["file.py", "dir/file.py"], "match", "*.py", "dir/*", ["file.py"], "Include *.py, exclude files directly in dir"),
+            (["root.py", "adir/a.py", "bdir/b.py"], "match", "a*/*.py", None, ["adir/a.py"], "Include files in dirs starting with 'a'"),
+            (["a.txt", "b.log"], "match", "*.py", None, [], "No files match include pattern"),
+            (["a.py", "b.py"], "match", None, "*.py", [], "All files match exclude pattern"),
+            (["a.py", "b.py"], "match", "a.*", "*.py", [], "Include a.* but exclude *.py -> empty"),
+            (["a.py", "b.py"], "match", "*.py", "b.*", ["a.py"], "Include *.py but exclude b.* -> a.py"),
+        ],
+        ids=lambda x: x if isinstance(x, str) else "",  # Use description as test ID
+    )
+    def test_search_files_include_exclude(
+        self, file_paths, pattern, paths_include_glob, paths_exclude_glob, expected_matched_files, description
+    ):
+        """
+        Test the include/exclude glob filtering logic in search_files using PathSpec patterns.
+        """
+        results = search_files(
+            relative_file_paths=file_paths,
+            pattern=pattern,
+            file_reader=mock_reader_always_match,
+            paths_include_glob=paths_include_glob,
+            paths_exclude_glob=paths_exclude_glob,
+            context_lines_before=0,  # No context needed for this test focus
+            context_lines_after=0,
+        )
+
+        # Extract the source file paths from the results
+        actual_matched_files = sorted([result.source_file_path for result in results if result.source_file_path])
+
+        # Assert that the matched files are exactly the ones expected
+        assert actual_matched_files == sorted(expected_matched_files)
+
+        # Basic check on results structure if files were expected
+        if expected_matched_files:
+            assert len(results) == len(expected_matched_files)
+            for result in results:
+                assert len(result.matched_lines) == 1  # Mock reader returns one matching line
+                assert result.matched_lines[0].line_content == "This line contains a match."
+                assert result.matched_lines[0].match_type == LineType.MATCH
+
+    @pytest.mark.parametrize(
+        "file_paths, pattern, paths_include_glob, paths_exclude_glob, expected_matched_files, description",
+        [
+            # Glob patterns that were problematic with gitignore syntax
+            (
+                ["src/serena/agent.py", "src/serena/process_isolated_agent.py", "test/agent.py"],
+                "match",
+                "src/**agent.py",
+                None,
+                ["src/serena/agent.py", "src/serena/process_isolated_agent.py"],
+                "Glob: src/**agent.py should match files ending with agent.py under src/",
+            ),
+            (
+                ["src/serena/agent.py", "src/serena/process_isolated_agent.py", "other/agent.py"],
+                "match",
+                "**agent.py",
+                None,
+                ["src/serena/agent.py", "src/serena/process_isolated_agent.py", "other/agent.py"],
+                "Glob: **agent.py should match files ending with agent.py anywhere",
+            ),
+            (
+                ["dir/subdir/file.py", "dir/other/file.py", "elsewhere/file.py"],
+                "match",
+                "dir/**file.py",
+                None,
+                ["dir/subdir/file.py", "dir/other/file.py"],
+                "Glob: dir/**file.py should match files ending with file.py under dir/",
+            ),
+            (
+                ["src/a/b/c/test.py", "src/x/test.py", "other/test.py"],
+                "match",
+                "src/**/test.py",
+                None,
+                ["src/a/b/c/test.py", "src/x/test.py"],
+                "Glob: src/**/test.py should match test.py files under src/ at any depth",
+            ),
+            # Edge cases for ** patterns
+            (
+                ["agent.py", "src/agent.py", "src/serena/agent.py"],
+                "match",
+                "**agent.py",
+                None,
+                ["agent.py", "src/agent.py", "src/serena/agent.py"],
+                "Glob: **agent.py should match at root and any depth",
+            ),
+            (["file.txt", "src/file.txt"], "match", "src/**", None, ["src/file.txt"], "Glob: src/** should match everything under src/"),
+        ],
+        ids=lambda x: x if isinstance(x, str) else "",  # Use description as test ID
+    )
+    def test_search_files_glob_patterns(
+        self, file_paths, pattern, paths_include_glob, paths_exclude_glob, expected_matched_files, description
+    ):
+        """
+        Test glob patterns that were problematic with the previous gitignore-based implementation.
+        """
+        results = search_files(
+            relative_file_paths=file_paths,
+            pattern=pattern,
+            file_reader=mock_reader_always_match,
+            paths_include_glob=paths_include_glob,
+            paths_exclude_glob=paths_exclude_glob,
+            context_lines_before=0,
+            context_lines_after=0,
+        )
+
+        # Extract the source file paths from the results
+        actual_matched_files = sorted([result.source_file_path for result in results if result.source_file_path])
+
+        # Assert that the matched files are exactly the ones expected
+        assert actual_matched_files == sorted(
+            expected_matched_files
+        ), f"Pattern '{paths_include_glob}' failed: expected {sorted(expected_matched_files)}, got {actual_matched_files}"
+
+        # Basic check on results structure if files were expected
+        if expected_matched_files:
+            assert len(results) == len(expected_matched_files)
+            for result in results:
+                assert len(result.matched_lines) == 1  # Mock reader returns one matching line
+                assert result.matched_lines[0].line_content == "This line contains a match."
+                assert result.matched_lines[0].match_type == LineType.MATCH
+
+    def test_search_files_no_pattern_match_in_content(self):
+        """Test that no results are returned if the pattern doesn't match the file content, even if files pass filters."""
+        file_paths = ["a.py", "b.txt"]
+        pattern = "non_existent_pattern_in_mock_content"  # This won't match mock_reader_always_match content
+        results = search_files(
+            relative_file_paths=file_paths,
+            pattern=pattern,
+            file_reader=mock_reader_always_match,  # Content is "This line contains a match."
+            paths_include_glob=None,  # Both files would pass filters
+            paths_exclude_glob=None,
+        )
+        assert len(results) == 0, "Should not find matches if pattern doesn't match content"
+
+    def test_search_files_regex_pattern_with_filters(self):
+        """Test using a regex pattern works correctly along with include/exclude filters."""
+
+        def specific_mock_reader(file_path: str) -> str:
+            # Provide different content for different files to test regex matching
+            if file_path == "a.py":  # noqa: SIM116
+                return "File A: value=123\nFile A: value=456"
+            elif file_path == "b.py":
+                return "File B: value=789"
+            elif file_path == "c.txt":
+                return "File C: value=000"
+            return "No values here."
+
+        file_paths = ["a.py", "b.py", "c.txt"]
+        pattern = r"value=(\d+)"
+
+        results = search_files(
+            relative_file_paths=file_paths,
+            pattern=pattern,
+            file_reader=specific_mock_reader,
+            paths_include_glob="*.py",  # Only include .py files
+            paths_exclude_glob="b.*",  # Exclude files starting with b
+        )
+
+        # Expected: a.py included, b.py excluded by glob, c.txt excluded by glob
+        # a.py has two matches for the regex pattern
+        assert len(results) == 2, "Expected 2 matches only from a.py"
+        actual_matched_files = sorted([result.source_file_path for result in results if result.source_file_path])
+        assert actual_matched_files == ["a.py", "a.py"], "Both matches should be from a.py"
+        # Check the content of the matched lines
+        assert results[0].matched_lines[0].line_content == "File A: value=123"
+        assert results[1].matched_lines[0].line_content == "File A: value=456"
+
+    def test_search_files_context_lines_with_filters(self):
+        """Test context lines are included correctly when filters are active."""
+
+        def context_mock_reader(file_path: str) -> str:
+            if file_path == "include_me.txt":
+                return "Line before 1\nLine before 2\nMATCH HERE\nLine after 1\nLine after 2"
+            elif file_path == "exclude_me.log":
+                return "Noise\nMATCH HERE\nNoise"
+            return "No match"
+
+        file_paths = ["include_me.txt", "exclude_me.log"]
+        pattern = "MATCH HERE"
+
+        results = search_files(
+            relative_file_paths=file_paths,
+            pattern=pattern,
+            file_reader=context_mock_reader,
+            paths_include_glob="*.txt",  # Only include .txt files
+            paths_exclude_glob=None,
+            context_lines_before=1,
+            context_lines_after=1,
+        )
+
+        # Expected: Only include_me.txt should be processed and matched
+        assert len(results) == 1, "Expected only one result from the included file"
+        result = results[0]
+        assert result.source_file_path == "include_me.txt"
+        assert len(result.lines) == 3, "Expected 3 lines (1 before, 1 match, 1 after)"
+        assert result.lines[0].line_content == "Line before 2", "Incorrect 'before' context line"
+        assert result.lines[0].match_type == LineType.BEFORE_MATCH
+        assert result.lines[1].line_content == "MATCH HERE", "Incorrect 'match' line"
+        assert result.lines[1].match_type == LineType.MATCH
+        assert result.lines[2].line_content == "Line after 1", "Incorrect 'after' context line"
+        assert result.lines[2].match_type == LineType.AFTER_MATCH
+
+
+class TestGlobMatch:
+    """Test the glob_match function directly."""
+
+    @pytest.mark.parametrize(
+        "pattern, path, expected",
+        [
+            # Basic wildcard patterns
+            ("*.py", "file.py", True),
+            ("*.py", "file.txt", False),
+            ("*agent.py", "agent.py", True),
+            ("*agent.py", "process_isolated_agent.py", True),
+            ("*agent.py", "agent_test.py", False),
+            # Double asterisk patterns
+            ("**agent.py", "agent.py", True),
+            ("**agent.py", "src/agent.py", True),
+            ("**agent.py", "src/serena/agent.py", True),
+            ("**agent.py", "src/serena/process_isolated_agent.py", True),
+            ("**agent.py", "agent_test.py", False),
+            # Prefix with double asterisk
+            ("src/**agent.py", "src/agent.py", True),
+            ("src/**agent.py", "src/serena/agent.py", True),
+            ("src/**agent.py", "src/serena/process_isolated_agent.py", True),
+            ("src/**agent.py", "other/agent.py", False),
+            ("src/**agent.py", "src/agent_test.py", False),
+            # Directory patterns
+            ("src/**", "src/file.py", True),
+            ("src/**", "src/dir/file.py", True),
+            ("src/**", "other/file.py", False),
+            # Exact matches with double asterisk
+            ("src/**/test.py", "src/test.py", True),
+            ("src/**/test.py", "src/a/b/test.py", True),
+            ("src/**/test.py", "src/test_file.py", False),
+            # Simple patterns without asterisks
+            ("src/file.py", "src/file.py", True),
+            ("src/file.py", "src/other.py", False),
+        ],
+    )
+    def test_glob_match(self, pattern, path, expected):
+        """Test glob_match function with various patterns."""
+        from src.serena.text_utils import glob_match
+
+        assert glob_match(pattern, path) == expected

projects/ui/serena-new/test/serena/test_tool_parameter_types.py

@@ -0,0 +1,39 @@
+import logging
+
+import pytest
+
+from serena.config.serena_config import SerenaConfig
+from serena.mcp import SerenaMCPFactorySingleProcess
+from serena.tools.tools_base import ToolRegistry
+
+
+@pytest.mark.parametrize("context", ("chatgpt", "codex", "oaicompat-agent"))
+def test_all_tool_parameters_have_type(context):
+    """
+    For every tool exposed by Serena, ensure that the generated
+    Open‑AI schema contains a ``type`` entry for each parameter.
+    """
+    cfg = SerenaConfig(gui_log_window_enabled=False, web_dashboard=False, log_level=logging.ERROR)
+    registry = ToolRegistry()
+    cfg.included_optional_tools = tuple(registry.get_tool_names_optional())
+    factory = SerenaMCPFactorySingleProcess(context=context)
+    # Initialize the agent so that the tools are available
+    factory._instantiate_agent(cfg, [])
+    tools = list(factory._iter_tools())
+
+    for tool in tools:
+        mcp_tool = factory.make_mcp_tool(tool, openai_tool_compatible=True)
+        params = mcp_tool.parameters
+
+        # Collect any parameter that lacks a type
+        issues = []
+        print(f"Checking tool {tool}")
+
+        if "properties" not in params:
+            issues.append(f"Tool {tool.get_name()!r} missing properties section")
+        else:
+            for pname, prop in params["properties"].items():
+                if "type" not in prop:
+                    issues.append(f"Tool {tool.get_name()!r} parameter {pname!r} missing 'type'")
+        if issues:
+            raise AssertionError("\n".join(issues))