Add files using upload-large-folder tool

projects/ui/serena-new/test/serena/config/test_serena_config.py

@@ -0,0 +1,138 @@
+import shutil
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from serena.config.serena_config import ProjectConfig
+from solidlsp.ls_config import Language
+
+
+class TestProjectConfigAutogenerate:
+    """Test class for ProjectConfig autogeneration functionality."""
+
+    def setup_method(self):
+        """Set up test environment before each test method."""
+        # Create a temporary directory for testing
+        self.test_dir = tempfile.mkdtemp()
+        self.project_path = Path(self.test_dir)
+
+    def teardown_method(self):
+        """Clean up test environment after each test method."""
+        # Remove the temporary directory
+        shutil.rmtree(self.test_dir)
+
+    def test_autogenerate_empty_directory(self):
+        """Test that autogenerate raises ValueError with helpful message for empty directory."""
+        with pytest.raises(ValueError) as exc_info:
+            ProjectConfig.autogenerate(self.project_path, save_to_disk=False)
+
+        error_message = str(exc_info.value)
+        # Check that the error message contains all the key information
+        assert "No source files found" in error_message
+        assert str(self.project_path.resolve()) in error_message
+        assert "To use Serena with this project" in error_message
+        assert "Add source files in one of the supported languages" in error_message
+        assert "Create a project configuration file manually" in error_message
+        assert str(Path(".serena") / "project.yml") in error_message
+        assert "Example project.yml:" in error_message
+        assert f"project_name: {self.project_path.name}" in error_message
+        assert "language: python" in error_message
+
+    def test_autogenerate_with_python_files(self):
+        """Test successful autogeneration with Python source files."""
+        # Create a Python file
+        python_file = self.project_path / "main.py"
+        python_file.write_text("def hello():\n    print('Hello, world!')\n")
+
+        # Run autogenerate
+        config = ProjectConfig.autogenerate(self.project_path, save_to_disk=False)
+
+        # Verify the configuration
+        assert config.project_name == self.project_path.name
+        assert config.language == Language.PYTHON
+
+    def test_autogenerate_with_multiple_languages(self):
+        """Test autogeneration picks dominant language when multiple are present."""
+        # Create files for multiple languages
+        (self.project_path / "main.py").write_text("print('Python')")
+        (self.project_path / "util.py").write_text("def util(): pass")
+        (self.project_path / "small.js").write_text("console.log('JS');")
+
+        # Run autogenerate - should pick Python as dominant
+        config = ProjectConfig.autogenerate(self.project_path, save_to_disk=False)
+
+        assert config.language == Language.PYTHON
+
+    def test_autogenerate_saves_to_disk(self):
+        """Test that autogenerate can save the configuration to disk."""
+        # Create a Go file
+        go_file = self.project_path / "main.go"
+        go_file.write_text("package main\n\nfunc main() {}\n")
+
+        # Run autogenerate with save_to_disk=True
+        config = ProjectConfig.autogenerate(self.project_path, save_to_disk=True)
+
+        # Verify the configuration file was created
+        config_path = self.project_path / ".serena" / "project.yml"
+        assert config_path.exists()
+
+        # Verify the content
+        assert config.language == Language.GO
+
+    def test_autogenerate_nonexistent_path(self):
+        """Test that autogenerate raises FileNotFoundError for non-existent path."""
+        non_existent = self.project_path / "does_not_exist"
+
+        with pytest.raises(FileNotFoundError) as exc_info:
+            ProjectConfig.autogenerate(non_existent, save_to_disk=False)
+
+        assert "Project root not found" in str(exc_info.value)
+
+    def test_autogenerate_with_gitignored_files_only(self):
+        """Test autogenerate behavior when only gitignored files exist."""
+        # Create a .gitignore that ignores all Python files
+        gitignore = self.project_path / ".gitignore"
+        gitignore.write_text("*.py\n")
+
+        # Create Python files that will be ignored
+        (self.project_path / "ignored.py").write_text("print('ignored')")
+
+        # Should still raise ValueError as no source files are detected
+        with pytest.raises(ValueError) as exc_info:
+            ProjectConfig.autogenerate(self.project_path, save_to_disk=False)
+
+        assert "No source files found" in str(exc_info.value)
+
+    def test_autogenerate_custom_project_name(self):
+        """Test autogenerate with custom project name."""
+        # Create a TypeScript file
+        ts_file = self.project_path / "index.ts"
+        ts_file.write_text("const greeting: string = 'Hello';\n")
+
+        # Run autogenerate with custom name
+        custom_name = "my-custom-project"
+        config = ProjectConfig.autogenerate(self.project_path, project_name=custom_name, save_to_disk=False)
+
+        assert config.project_name == custom_name
+        assert config.language == Language.TYPESCRIPT
+
+    def test_autogenerate_error_message_format(self):
+        """Test the specific format of the error message for better user experience."""
+        with pytest.raises(ValueError) as exc_info:
+            ProjectConfig.autogenerate(self.project_path, save_to_disk=False)
+
+        error_lines = str(exc_info.value).split("\n")
+
+        # Verify the structure of the error message
+        assert len(error_lines) >= 8  # Should have multiple lines of helpful information
+
+        # Check for numbered instructions
+        assert any("1." in line for line in error_lines)
+        assert any("2." in line for line in error_lines)
+
+        # Check for supported languages list
+        assert any("Python" in line and "TypeScript" in line for line in error_lines)
+
+        # Check example includes comment about language options
+        assert any("# or typescript, java, csharp" in line for line in error_lines)

projects/ui/serena-new/test/serena/util/test_exception.py

@@ -0,0 +1,116 @@
+import os
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
+
+from serena.util.exception import is_headless_environment, show_fatal_exception_safe
+
+
+class TestHeadlessEnvironmentDetection:
+    """Test class for headless environment detection functionality."""
+
+    def test_is_headless_no_display(self):
+        """Test that environment without DISPLAY is detected as headless on Linux."""
+        with patch("sys.platform", "linux"):
+            with patch.dict(os.environ, {}, clear=True):
+                assert is_headless_environment() is True
+
+    def test_is_headless_ssh_connection(self):
+        """Test that SSH sessions are detected as headless."""
+        with patch("sys.platform", "linux"):
+            with patch.dict(os.environ, {"SSH_CONNECTION": "192.168.1.1 22 192.168.1.2 22", "DISPLAY": ":0"}):
+                assert is_headless_environment() is True
+
+            with patch.dict(os.environ, {"SSH_CLIENT": "192.168.1.1 22 22", "DISPLAY": ":0"}):
+                assert is_headless_environment() is True
+
+    def test_is_headless_wsl(self):
+        """Test that WSL environment is detected as headless."""
+        # Skip this test on Windows since os.uname doesn't exist
+        if not hasattr(os, "uname"):
+            pytest.skip("os.uname not available on this platform")
+
+        with patch("sys.platform", "linux"):
+            with patch("os.uname") as mock_uname:
+                mock_uname.return_value = Mock(release="5.15.153.1-microsoft-standard-WSL2")
+                with patch.dict(os.environ, {"DISPLAY": ":0"}):
+                    assert is_headless_environment() is True
+
+    def test_is_headless_docker(self):
+        """Test that Docker containers are detected as headless."""
+        with patch("sys.platform", "linux"):
+            # Test with CI environment variable
+            with patch.dict(os.environ, {"CI": "true", "DISPLAY": ":0"}):
+                assert is_headless_environment() is True
+
+            # Test with CONTAINER environment variable
+            with patch.dict(os.environ, {"CONTAINER": "docker", "DISPLAY": ":0"}):
+                assert is_headless_environment() is True
+
+            # Test with .dockerenv file
+            with patch("os.path.exists") as mock_exists:
+                mock_exists.return_value = True
+                with patch.dict(os.environ, {"DISPLAY": ":0"}):
+                    assert is_headless_environment() is True
+
+    def test_is_not_headless_windows(self):
+        """Test that Windows is never detected as headless."""
+        with patch("sys.platform", "win32"):
+            # Even without DISPLAY, Windows should not be headless
+            with patch.dict(os.environ, {}, clear=True):
+                assert is_headless_environment() is False
+
+
+class TestShowFatalExceptionSafe:
+    """Test class for safe fatal exception display functionality."""
+
+    @patch("serena.util.exception.is_headless_environment", return_value=True)
+    @patch("serena.util.exception.log")
+    def test_show_fatal_exception_safe_headless(self, mock_log, mock_is_headless):
+        """Test that GUI is not attempted in headless environment."""
+        test_exception = ValueError("Test error")
+
+        # The import should never happen in headless mode
+        with patch("serena.gui_log_viewer.show_fatal_exception") as mock_show_gui:
+            show_fatal_exception_safe(test_exception)
+            mock_show_gui.assert_not_called()
+
+        # Verify debug log about skipping GUI
+        mock_log.debug.assert_called_once_with("Skipping GUI error display in headless environment")
+
+    @patch("serena.util.exception.is_headless_environment", return_value=False)
+    @patch("serena.util.exception.log")
+    def test_show_fatal_exception_safe_with_gui(self, mock_log, mock_is_headless):
+        """Test that GUI is attempted when not in headless environment."""
+        test_exception = ValueError("Test error")
+
+        # Mock the GUI function
+        with patch("serena.gui_log_viewer.show_fatal_exception") as mock_show_gui:
+            show_fatal_exception_safe(test_exception)
+            mock_show_gui.assert_called_once_with(test_exception)
+
+    @patch("serena.util.exception.is_headless_environment", return_value=False)
+    @patch("serena.util.exception.log")
+    def test_show_fatal_exception_safe_gui_failure(self, mock_log, mock_is_headless):
+        """Test graceful handling when GUI display fails."""
+        test_exception = ValueError("Test error")
+        gui_error = ImportError("No module named 'tkinter'")
+
+        # Mock the GUI function to raise an exception
+        with patch("serena.gui_log_viewer.show_fatal_exception", side_effect=gui_error):
+            show_fatal_exception_safe(test_exception)
+
+        # Verify debug log about GUI failure
+        mock_log.debug.assert_called_with(f"Failed to show GUI error dialog: {gui_error}")
+
+    def test_show_fatal_exception_safe_prints_to_stderr(self):
+        """Test that exceptions are always printed to stderr."""
+        test_exception = ValueError("Test error message")
+
+        with patch("sys.stderr", new_callable=MagicMock) as mock_stderr:
+            with patch("serena.util.exception.is_headless_environment", return_value=True):
+                with patch("serena.util.exception.log"):
+                    show_fatal_exception_safe(test_exception)
+
+        # Verify print was called with the correct arguments
+        mock_stderr.write.assert_any_call("Fatal exception: Test error message")

projects/ui/serena-new/test/serena/util/test_file_system.py

@@ -0,0 +1,708 @@
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+# Assuming the gitignore parser code is in a module named 'gitignore_parser'
+from serena.util.file_system import GitignoreParser, GitignoreSpec
+
+
+class TestGitignoreParser:
+    """Test class for GitignoreParser functionality."""
+
+    def setup_method(self):
+        """Set up test environment before each test method."""
+        # Create a temporary directory for testing
+        self.test_dir = tempfile.mkdtemp()
+        self.repo_path = Path(self.test_dir)
+
+        # Create test repository structure
+        self._create_repo_structure()
+
+    def teardown_method(self):
+        """Clean up test environment after each test method."""
+        # Remove the temporary directory
+        shutil.rmtree(self.test_dir)
+
+    def _create_repo_structure(self):
+        """
+        Create a test repository structure with multiple gitignore files.
+
+        Structure:
+        repo/
+        ├── .gitignore
+        ├── file1.txt
+        ├── test.log
+        ├── src/
+        │   ├── .gitignore
+        │   ├── main.py
+        │   ├── test.log
+        │   ├── build/
+        │   │   └── output.o
+        │   └── lib/
+        │       ├── .gitignore
+        │       └── cache.tmp
+        └── docs/
+            ├── .gitignore
+            ├── api.md
+            └── temp/
+                └── draft.md
+        """
+        # Create directories
+        (self.repo_path / "src").mkdir()
+        (self.repo_path / "src" / "build").mkdir()
+        (self.repo_path / "src" / "lib").mkdir()
+        (self.repo_path / "docs").mkdir()
+        (self.repo_path / "docs" / "temp").mkdir()
+
+        # Create files
+        (self.repo_path / "file1.txt").touch()
+        (self.repo_path / "test.log").touch()
+        (self.repo_path / "src" / "main.py").touch()
+        (self.repo_path / "src" / "test.log").touch()
+        (self.repo_path / "src" / "build" / "output.o").touch()
+        (self.repo_path / "src" / "lib" / "cache.tmp").touch()
+        (self.repo_path / "docs" / "api.md").touch()
+        (self.repo_path / "docs" / "temp" / "draft.md").touch()
+
+        # Create root .gitignore
+        root_gitignore = self.repo_path / ".gitignore"
+        root_gitignore.write_text(
+            """# Root gitignore
+*.log
+/build/
+"""
+        )
+
+        # Create src/.gitignore
+        src_gitignore = self.repo_path / "src" / ".gitignore"
+        src_gitignore.write_text(
+            """# Source gitignore
+*.o
+build/
+!important.log
+"""
+        )
+
+        # Create src/lib/.gitignore (deeply nested)
+        src_lib_gitignore = self.repo_path / "src" / "lib" / ".gitignore"
+        src_lib_gitignore.write_text(
+            """# Library gitignore
+*.tmp
+*.cache
+"""
+        )
+
+        # Create docs/.gitignore
+        docs_gitignore = self.repo_path / "docs" / ".gitignore"
+        docs_gitignore.write_text(
+            """# Docs gitignore
+temp/
+*.tmp
+"""
+        )
+
+    def test_initialization(self):
+        """Test GitignoreParser initialization."""
+        parser = GitignoreParser(str(self.repo_path))
+
+        assert parser.repo_root == str(self.repo_path.absolute())
+        assert len(parser.get_ignore_specs()) == 4
+
+    def test_find_gitignore_files(self):
+        """Test finding all gitignore files in repository, including deeply nested ones."""
+        parser = GitignoreParser(str(self.repo_path))
+
+        # Get file paths from specs
+        gitignore_files = [spec.file_path for spec in parser.get_ignore_specs()]
+
+        # Convert to relative paths for easier testing
+        rel_paths = [os.path.relpath(f, self.repo_path) for f in gitignore_files]
+        rel_paths.sort()
+
+        assert len(rel_paths) == 4
+        assert ".gitignore" in rel_paths
+        assert os.path.join("src", ".gitignore") in rel_paths
+        assert os.path.join("src", "lib", ".gitignore") in rel_paths  # Deeply nested
+        assert os.path.join("docs", ".gitignore") in rel_paths
+
+    def test_parse_patterns_root_directory(self):
+        """Test parsing gitignore patterns in root directory."""
+        # Create a simple test case with only root gitignore
+        test_dir = self.repo_path / "test_root"
+        test_dir.mkdir()
+
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """*.log
+build/
+/temp.txt
+"""
+        )
+
+        parser = GitignoreParser(str(test_dir))
+        specs = parser.get_ignore_specs()
+
+        assert len(specs) == 1
+        patterns = specs[0].patterns
+
+        assert "*.log" in patterns
+        assert "build/" in patterns
+        assert "/temp.txt" in patterns
+
+    def test_parse_patterns_subdirectory(self):
+        """Test parsing gitignore patterns in subdirectory."""
+        # Create a test case with subdirectory gitignore
+        test_dir = self.repo_path / "test_sub"
+        test_dir.mkdir()
+        subdir = test_dir / "src"
+        subdir.mkdir()
+
+        gitignore = subdir / ".gitignore"
+        gitignore.write_text(
+            """*.o
+/build/
+test.log
+"""
+        )
+
+        parser = GitignoreParser(str(test_dir))
+        specs = parser.get_ignore_specs()
+
+        assert len(specs) == 1
+        patterns = specs[0].patterns
+
+        # Non-anchored pattern should get ** prefix
+        assert "src/**/*.o" in patterns
+        # Anchored pattern should not get ** prefix
+        assert "src/build/" in patterns
+        # Non-anchored pattern without slash
+        assert "src/**/test.log" in patterns
+
+    def test_should_ignore_root_patterns(self):
+        """Test ignoring files based on root .gitignore."""
+        parser = GitignoreParser(str(self.repo_path))
+
+        # Files that should be ignored
+        assert parser.should_ignore("test.log")
+        assert parser.should_ignore(str(self.repo_path / "test.log"))
+
+        # Files that should NOT be ignored
+        assert not parser.should_ignore("file1.txt")
+        assert not parser.should_ignore("src/main.py")
+
+    def test_should_ignore_subdirectory_patterns(self):
+        """Test ignoring files based on subdirectory .gitignore files."""
+        parser = GitignoreParser(str(self.repo_path))
+
+        # .o files in src should be ignored
+        assert parser.should_ignore("src/build/output.o")
+
+        # build/ directory in src should be ignored
+        assert parser.should_ignore("src/build/")
+
+        # temp/ directory in docs should be ignored
+        assert parser.should_ignore("docs/temp/draft.md")
+
+        # But temp/ outside docs should not be ignored by docs/.gitignore
+        assert not parser.should_ignore("temp/file.txt")
+
+        # Test deeply nested .gitignore in src/lib/
+        # .tmp files in src/lib should be ignored
+        assert parser.should_ignore("src/lib/cache.tmp")
+
+        # .cache files in src/lib should also be ignored
+        assert parser.should_ignore("src/lib/data.cache")
+
+        # But .tmp files outside src/lib should not be ignored by src/lib/.gitignore
+        assert not parser.should_ignore("src/other.tmp")
+
+    def test_anchored_vs_non_anchored_patterns(self):
+        """Test the difference between anchored and non-anchored patterns."""
+        # Create new test structure
+        test_dir = self.repo_path / "test_anchored"
+        test_dir.mkdir()
+        (test_dir / "src").mkdir()
+        (test_dir / "src" / "subdir").mkdir()
+        (test_dir / "src" / "subdir" / "deep").mkdir()
+
+        # Create src/.gitignore with both anchored and non-anchored patterns
+        gitignore = test_dir / "src" / ".gitignore"
+        gitignore.write_text(
+            """/temp.txt
+data.json
+"""
+        )
+
+        # Create test files
+        (test_dir / "src" / "temp.txt").touch()
+        (test_dir / "src" / "data.json").touch()
+        (test_dir / "src" / "subdir" / "temp.txt").touch()
+        (test_dir / "src" / "subdir" / "data.json").touch()
+        (test_dir / "src" / "subdir" / "deep" / "data.json").touch()
+
+        parser = GitignoreParser(str(test_dir))
+
+        # Anchored pattern /temp.txt should only match in src/
+        assert parser.should_ignore("src/temp.txt")
+        assert not parser.should_ignore("src/subdir/temp.txt")
+
+        # Non-anchored pattern data.json should match anywhere under src/
+        assert parser.should_ignore("src/data.json")
+        assert parser.should_ignore("src/subdir/data.json")
+        assert parser.should_ignore("src/subdir/deep/data.json")
+
+    def test_root_anchored_patterns(self):
+        """Test anchored patterns in root .gitignore only match root-level files."""
+        # Create new test structure for root anchored patterns
+        test_dir = self.repo_path / "test_root_anchored"
+        test_dir.mkdir()
+        (test_dir / "src").mkdir()
+        (test_dir / "docs").mkdir()
+        (test_dir / "src" / "nested").mkdir()
+
+        # Create root .gitignore with anchored patterns
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """/config.json
+/temp.log
+/build
+*.pyc
+"""
+        )
+
+        # Create test files at root level
+        (test_dir / "config.json").touch()
+        (test_dir / "temp.log").touch()
+        (test_dir / "build").mkdir()
+        (test_dir / "file.pyc").touch()
+
+        # Create same-named files in subdirectories
+        (test_dir / "src" / "config.json").touch()
+        (test_dir / "src" / "temp.log").touch()
+        (test_dir / "src" / "build").mkdir()
+        (test_dir / "src" / "file.pyc").touch()
+        (test_dir / "docs" / "config.json").touch()
+        (test_dir / "docs" / "temp.log").touch()
+        (test_dir / "src" / "nested" / "config.json").touch()
+        (test_dir / "src" / "nested" / "temp.log").touch()
+        (test_dir / "src" / "nested" / "build").mkdir()
+
+        parser = GitignoreParser(str(test_dir))
+
+        # Anchored patterns should only match root-level files
+        assert parser.should_ignore("config.json")
+        assert not parser.should_ignore("src/config.json")
+        assert not parser.should_ignore("docs/config.json")
+        assert not parser.should_ignore("src/nested/config.json")
+
+        assert parser.should_ignore("temp.log")
+        assert not parser.should_ignore("src/temp.log")
+        assert not parser.should_ignore("docs/temp.log")
+        assert not parser.should_ignore("src/nested/temp.log")
+
+        assert parser.should_ignore("build")
+        assert not parser.should_ignore("src/build")
+        assert not parser.should_ignore("src/nested/build")
+
+        # Non-anchored patterns should match everywhere
+        assert parser.should_ignore("file.pyc")
+        assert parser.should_ignore("src/file.pyc")
+
+    def test_mixed_anchored_and_non_anchored_root_patterns(self):
+        """Test mix of anchored and non-anchored patterns in root .gitignore."""
+        test_dir = self.repo_path / "test_mixed_patterns"
+        test_dir.mkdir()
+        (test_dir / "app").mkdir()
+        (test_dir / "tests").mkdir()
+        (test_dir / "app" / "modules").mkdir()
+
+        # Create root .gitignore with mixed patterns
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """/secrets.env
+/dist/
+node_modules/
+*.tmp
+/app/local.config
+debug.log
+"""
+        )
+
+        # Create test files and directories
+        (test_dir / "secrets.env").touch()
+        (test_dir / "dist").mkdir()
+        (test_dir / "node_modules").mkdir()
+        (test_dir / "file.tmp").touch()
+        (test_dir / "app" / "local.config").touch()
+        (test_dir / "debug.log").touch()
+
+        # Create same files in subdirectories
+        (test_dir / "app" / "secrets.env").touch()
+        (test_dir / "app" / "dist").mkdir()
+        (test_dir / "app" / "node_modules").mkdir()
+        (test_dir / "app" / "file.tmp").touch()
+        (test_dir / "app" / "debug.log").touch()
+        (test_dir / "tests" / "secrets.env").touch()
+        (test_dir / "tests" / "node_modules").mkdir()
+        (test_dir / "tests" / "debug.log").touch()
+        (test_dir / "app" / "modules" / "local.config").touch()
+
+        parser = GitignoreParser(str(test_dir))
+
+        # Anchored patterns should only match at root
+        assert parser.should_ignore("secrets.env")
+        assert not parser.should_ignore("app/secrets.env")
+        assert not parser.should_ignore("tests/secrets.env")
+
+        assert parser.should_ignore("dist")
+        assert not parser.should_ignore("app/dist")
+
+        assert parser.should_ignore("app/local.config")
+        assert not parser.should_ignore("app/modules/local.config")
+
+        # Non-anchored patterns should match everywhere
+        assert parser.should_ignore("node_modules")
+        assert parser.should_ignore("app/node_modules")
+        assert parser.should_ignore("tests/node_modules")
+
+        assert parser.should_ignore("file.tmp")
+        assert parser.should_ignore("app/file.tmp")
+
+        assert parser.should_ignore("debug.log")
+        assert parser.should_ignore("app/debug.log")
+        assert parser.should_ignore("tests/debug.log")
+
+    def test_negation_patterns(self):
+        """Test negation patterns are parsed correctly."""
+        test_dir = self.repo_path / "test_negation"
+        test_dir.mkdir()
+
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """*.log
+!important.log
+!src/keep.log
+"""
+        )
+
+        parser = GitignoreParser(str(test_dir))
+        specs = parser.get_ignore_specs()
+
+        assert len(specs) == 1
+        patterns = specs[0].patterns
+
+        assert "*.log" in patterns
+        assert "!important.log" in patterns
+        assert "!src/keep.log" in patterns
+
+    def test_comments_and_empty_lines(self):
+        """Test that comments and empty lines are ignored."""
+        test_dir = self.repo_path / "test_comments"
+        test_dir.mkdir()
+
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """# This is a comment
+*.log
+
+# Another comment
+  # Indented comment
+
+build/
+"""
+        )
+
+        parser = GitignoreParser(str(test_dir))
+        specs = parser.get_ignore_specs()
+
+        assert len(specs) == 1
+        patterns = specs[0].patterns
+
+        assert len(patterns) == 2
+        assert "*.log" in patterns
+        assert "build/" in patterns
+
+    def test_escaped_characters(self):
+        """Test escaped special characters."""
+        test_dir = self.repo_path / "test_escaped"
+        test_dir.mkdir()
+
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """\\#not-a-comment.txt
+\\!not-negation.txt
+"""
+        )
+
+        parser = GitignoreParser(str(test_dir))
+        specs = parser.get_ignore_specs()
+
+        assert len(specs) == 1
+        patterns = specs[0].patterns
+
+        assert "#not-a-comment.txt" in patterns
+        assert "!not-negation.txt" in patterns
+
+    def test_escaped_negation_patterns(self):
+        test_dir = self.repo_path / "test_escaped_negation"
+        test_dir.mkdir()
+
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """*.log
+\\!not-negation.log
+!actual-negation.log
+"""
+        )
+
+        parser = GitignoreParser(str(test_dir))
+        specs = parser.get_ignore_specs()
+
+        assert len(specs) == 1
+        patterns = specs[0].patterns
+
+        # Key assertions: escaped exclamation becomes literal, real negation preserved
+        assert "!not-negation.log" in patterns  # escaped -> literal
+        assert "!actual-negation.log" in patterns  # real negation preserved
+
+        # Test the actual behavioral difference between escaped and real negation:
+        # *.log pattern should ignore test.log
+        assert parser.should_ignore("test.log")
+
+        # Escaped negation file should still be ignored by *.log pattern
+        assert parser.should_ignore("!not-negation.log")
+
+        # Actual negation should override the *.log pattern
+        assert not parser.should_ignore("actual-negation.log")
+
+    def test_glob_patterns(self):
+        """Test various glob patterns work correctly."""
+        test_dir = self.repo_path / "test_glob"
+        test_dir.mkdir()
+
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """*.pyc
+**/*.tmp
+src/*.o
+!src/important.o
+[Tt]est*
+"""
+        )
+
+        # Create test files
+        (test_dir / "src").mkdir()
+        (test_dir / "src" / "nested").mkdir()
+        (test_dir / "file.pyc").touch()
+        (test_dir / "src" / "file.pyc").touch()
+        (test_dir / "file.tmp").touch()
+        (test_dir / "src" / "nested" / "file.tmp").touch()
+        (test_dir / "src" / "file.o").touch()
+        (test_dir / "src" / "important.o").touch()
+        (test_dir / "Test.txt").touch()
+        (test_dir / "test.log").touch()
+
+        parser = GitignoreParser(str(test_dir))
+
+        # *.pyc should match everywhere
+        assert parser.should_ignore("file.pyc")
+        assert parser.should_ignore("src/file.pyc")
+
+        # **/*.tmp should match all .tmp files
+        assert parser.should_ignore("file.tmp")
+        assert parser.should_ignore("src/nested/file.tmp")
+
+        # src/*.o should only match .o files directly in src/
+        assert parser.should_ignore("src/file.o")
+
+        # Character class patterns
+        assert parser.should_ignore("Test.txt")
+        assert parser.should_ignore("test.log")
+
+    def test_empty_gitignore(self):
+        """Test handling of empty gitignore files."""
+        test_dir = self.repo_path / "test_empty"
+        test_dir.mkdir()
+
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text("")
+
+        parser = GitignoreParser(str(test_dir))
+
+        # Should not crash and should return empty list
+        assert len(parser.get_ignore_specs()) == 0
+
+    def test_malformed_gitignore(self):
+        """Test handling of malformed gitignore content."""
+        test_dir = self.repo_path / "test_malformed"
+        test_dir.mkdir()
+
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text(
+            """# Only comments and empty lines
+    
+# More comments
+    
+    """
+        )
+
+        parser = GitignoreParser(str(test_dir))
+
+        # Should handle gracefully
+        assert len(parser.get_ignore_specs()) == 0
+
+    def test_reload(self):
+        """Test reloading gitignore files."""
+        test_dir = self.repo_path / "test_reload"
+        test_dir.mkdir()
+
+        # Create initial gitignore
+        gitignore = test_dir / ".gitignore"
+        gitignore.write_text("*.log")
+
+        parser = GitignoreParser(str(test_dir))
+        assert len(parser.get_ignore_specs()) == 1
+        assert parser.should_ignore("test.log")
+
+        # Modify gitignore
+        gitignore.write_text("*.tmp")
+
+        # Without reload, should still use old patterns
+        assert parser.should_ignore("test.log")
+        assert not parser.should_ignore("test.tmp")
+
+        # After reload, should use new patterns
+        parser.reload()
+        assert not parser.should_ignore("test.log")
+        assert parser.should_ignore("test.tmp")
+
+    def test_gitignore_spec_matches(self):
+        """Test GitignoreSpec.matches method."""
+        spec = GitignoreSpec("/path/to/.gitignore", ["*.log", "build/", "!important.log"])
+
+        assert spec.matches("test.log")
+        assert spec.matches("build/output.o")
+        assert spec.matches("src/test.log")
+
+        # Note: Negation patterns in pathspec work differently than in git
+        # This is a limitation of the pathspec library
+
+    def test_subdirectory_gitignore_pattern_scoping(self):
+        """Test that subdirectory .gitignore patterns are scoped correctly."""
+        # Create test structure: foo/ with subdirectory bar/
+        test_dir = self.repo_path / "test_subdir_scoping"
+        test_dir.mkdir()
+        (test_dir / "foo").mkdir()
+        (test_dir / "foo" / "bar").mkdir()
+
+        # Create files in various locations
+        (test_dir / "foo.txt").touch()  # root level
+        (test_dir / "foo" / "foo.txt").touch()  # in foo/
+        (test_dir / "foo" / "bar" / "foo.txt").touch()  # in foo/bar/
+
+        # Test case 1: foo.txt in foo/.gitignore should only ignore in foo/ subtree
+        gitignore = test_dir / "foo" / ".gitignore"
+        gitignore.write_text("foo.txt\n")
+
+        parser = GitignoreParser(str(test_dir))
+
+        # foo.txt at root should NOT be ignored by foo/.gitignore
+        assert not parser.should_ignore("foo.txt"), "Root foo.txt should not be ignored by foo/.gitignore"
+
+        # foo.txt in foo/ should be ignored
+        assert parser.should_ignore("foo/foo.txt"), "foo/foo.txt should be ignored"
+
+        # foo.txt in foo/bar/ should be ignored (within foo/ subtree)
+        assert parser.should_ignore("foo/bar/foo.txt"), "foo/bar/foo.txt should be ignored"
+
+    def test_anchored_pattern_in_subdirectory(self):
+        """Test that anchored patterns in subdirectory only match immediate children."""
+        test_dir = self.repo_path / "test_anchored_subdir"
+        test_dir.mkdir()
+        (test_dir / "foo").mkdir()
+        (test_dir / "foo" / "bar").mkdir()
+
+        # Create files
+        (test_dir / "foo.txt").touch()  # root level
+        (test_dir / "foo" / "foo.txt").touch()  # in foo/
+        (test_dir / "foo" / "bar" / "foo.txt").touch()  # in foo/bar/
+
+        # Test case 2: /foo.txt in foo/.gitignore should only match foo/foo.txt
+        gitignore = test_dir / "foo" / ".gitignore"
+        gitignore.write_text("/foo.txt\n")
+
+        parser = GitignoreParser(str(test_dir))
+
+        # foo.txt at root should NOT be ignored
+        assert not parser.should_ignore("foo.txt"), "Root foo.txt should not be ignored"
+
+        # foo.txt directly in foo/ should be ignored
+        assert parser.should_ignore("foo/foo.txt"), "foo/foo.txt should be ignored by /foo.txt pattern"
+
+        # foo.txt in foo/bar/ should NOT be ignored (anchored pattern only matches immediate children)
+        assert not parser.should_ignore("foo/bar/foo.txt"), "foo/bar/foo.txt should NOT be ignored by /foo.txt pattern"
+
+    def test_double_star_pattern_scoping(self):
+        """Test that **/pattern in subdirectory only applies within that subtree."""
+        test_dir = self.repo_path / "test_doublestar_scope"
+        test_dir.mkdir()
+        (test_dir / "foo").mkdir()
+        (test_dir / "foo" / "bar").mkdir()
+        (test_dir / "other").mkdir()
+
+        # Create files
+        (test_dir / "foo.txt").touch()  # root level
+        (test_dir / "foo" / "foo.txt").touch()  # in foo/
+        (test_dir / "foo" / "bar" / "foo.txt").touch()  # in foo/bar/
+        (test_dir / "other" / "foo.txt").touch()  # in other/
+
+        # Test case 3: **/foo.txt in foo/.gitignore should only ignore within foo/ subtree
+        gitignore = test_dir / "foo" / ".gitignore"
+        gitignore.write_text("**/foo.txt\n")
+
+        parser = GitignoreParser(str(test_dir))
+
+        # foo.txt at root should NOT be ignored
+        assert not parser.should_ignore("foo.txt"), "Root foo.txt should not be ignored by foo/.gitignore"
+
+        # foo.txt in foo/ should be ignored
+        assert parser.should_ignore("foo/foo.txt"), "foo/foo.txt should be ignored"
+
+        # foo.txt in foo/bar/ should be ignored (within foo/ subtree)
+        assert parser.should_ignore("foo/bar/foo.txt"), "foo/bar/foo.txt should be ignored"
+
+        # foo.txt in other/ should NOT be ignored (outside foo/ subtree)
+        assert not parser.should_ignore("other/foo.txt"), "other/foo.txt should NOT be ignored by foo/.gitignore"
+
+    def test_anchored_double_star_pattern(self):
+        """Test that /**/pattern in subdirectory works correctly."""
+        test_dir = self.repo_path / "test_anchored_doublestar"
+        test_dir.mkdir()
+        (test_dir / "foo").mkdir()
+        (test_dir / "foo" / "bar").mkdir()
+        (test_dir / "other").mkdir()
+
+        # Create files
+        (test_dir / "foo.txt").touch()  # root level
+        (test_dir / "foo" / "foo.txt").touch()  # in foo/
+        (test_dir / "foo" / "bar" / "foo.txt").touch()  # in foo/bar/
+        (test_dir / "other" / "foo.txt").touch()  # in other/
+
+        # Test case 4: /**/foo.txt in foo/.gitignore should correctly ignore only within foo/ subtree
+        gitignore = test_dir / "foo" / ".gitignore"
+        gitignore.write_text("/**/foo.txt\n")
+
+        parser = GitignoreParser(str(test_dir))
+
+        # foo.txt at root should NOT be ignored
+        assert not parser.should_ignore("foo.txt"), "Root foo.txt should not be ignored"
+
+        # foo.txt in foo/ should be ignored
+        assert parser.should_ignore("foo/foo.txt"), "foo/foo.txt should be ignored"
+
+        # foo.txt in foo/bar/ should be ignored (within foo/ subtree)
+        assert parser.should_ignore("foo/bar/foo.txt"), "foo/bar/foo.txt should be ignored"
+
+        # foo.txt in other/ should NOT be ignored (outside foo/ subtree)
+        assert not parser.should_ignore("other/foo.txt"), "other/foo.txt should NOT be ignored by foo/.gitignore"

projects/ui/serena-new/test/solidlsp/bash/test_bash_basic.py

@@ -0,0 +1,121 @@
+"""
+Basic integration tests for the bash language server functionality.
+
+These tests validate the functionality of the language server APIs
+like request_document_symbols using the bash test repository.
+"""
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+
+@pytest.mark.bash
+class TestBashLanguageServerBasics:
+    """Test basic functionality of the bash language server."""
+
+    @pytest.mark.parametrize("language_server", [Language.BASH], indirect=True)
+    def test_bash_language_server_initialization(self, language_server: SolidLanguageServer) -> None:
+        """Test that bash language server can be initialized successfully."""
+        assert language_server is not None
+        assert language_server.language == Language.BASH
+
+    @pytest.mark.parametrize("language_server", [Language.BASH], indirect=True)
+    def test_bash_request_document_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test request_document_symbols for bash files."""
+        # Test getting symbols from main.sh
+        all_symbols, root_symbols = language_server.request_document_symbols("main.sh", include_body=False)
+
+        # Extract function symbols (LSP Symbol Kind 12)
+        function_symbols = [symbol for symbol in all_symbols if symbol.get("kind") == 12]
+        function_names = [symbol["name"] for symbol in function_symbols]
+
+        # Should detect all 3 functions from main.sh
+        assert "greet_user" in function_names, "Should find greet_user function"
+        assert "process_items" in function_names, "Should find process_items function"
+        assert "main" in function_names, "Should find main function"
+        assert len(function_symbols) >= 3, f"Should find at least 3 functions, found {len(function_symbols)}"
+
+    @pytest.mark.parametrize("language_server", [Language.BASH], indirect=True)
+    def test_bash_request_document_symbols_with_body(self, language_server: SolidLanguageServer) -> None:
+        """Test request_document_symbols with body extraction."""
+        # Test with include_body=True
+        all_symbols, root_symbols = language_server.request_document_symbols("main.sh", include_body=True)
+
+        function_symbols = [symbol for symbol in all_symbols if symbol.get("kind") == 12]
+
+        # Find greet_user function and check it has body
+        greet_user_symbol = next((sym for sym in function_symbols if sym["name"] == "greet_user"), None)
+        assert greet_user_symbol is not None, "Should find greet_user function"
+
+        if "body" in greet_user_symbol:
+            body = greet_user_symbol["body"]
+            assert "function greet_user()" in body, "Function body should contain function definition"
+            assert "case" in body.lower(), "Function body should contain case statement"
+
+    @pytest.mark.parametrize("language_server", [Language.BASH], indirect=True)
+    def test_bash_utils_functions(self, language_server: SolidLanguageServer) -> None:
+        """Test function detection in utils.sh file."""
+        # Test with utils.sh as well
+        utils_all_symbols, utils_root_symbols = language_server.request_document_symbols("utils.sh", include_body=False)
+
+        utils_function_symbols = [symbol for symbol in utils_all_symbols if symbol.get("kind") == 12]
+        utils_function_names = [symbol["name"] for symbol in utils_function_symbols]
+
+        # Should detect functions from utils.sh
+        expected_utils_functions = [
+            "to_uppercase",
+            "to_lowercase",
+            "trim_whitespace",
+            "backup_file",
+            "contains_element",
+            "log_message",
+            "is_valid_email",
+            "is_number",
+        ]
+
+        for func_name in expected_utils_functions:
+            assert func_name in utils_function_names, f"Should find {func_name} function in utils.sh"
+
+        assert len(utils_function_symbols) >= 8, f"Should find at least 8 functions in utils.sh, found {len(utils_function_symbols)}"
+
+    @pytest.mark.parametrize("language_server", [Language.BASH], indirect=True)
+    def test_bash_function_syntax_patterns(self, language_server: SolidLanguageServer) -> None:
+        """Test that LSP detects different bash function syntax patterns correctly."""
+        # Test main.sh (has both 'function' keyword and traditional syntax)
+        main_all_symbols, main_root_symbols = language_server.request_document_symbols("main.sh", include_body=False)
+        main_functions = [symbol for symbol in main_all_symbols if symbol.get("kind") == 12]
+        main_function_names = [func["name"] for func in main_functions]
+
+        # Test utils.sh (all use 'function' keyword)
+        utils_all_symbols, utils_root_symbols = language_server.request_document_symbols("utils.sh", include_body=False)
+        utils_functions = [symbol for symbol in utils_all_symbols if symbol.get("kind") == 12]
+        utils_function_names = [func["name"] for func in utils_functions]
+
+        # Verify LSP detects both syntax patterns
+        # main() uses traditional syntax: main() {
+        assert "main" in main_function_names, "LSP should detect traditional function syntax"
+
+        # Functions with 'function' keyword: function name() {
+        assert "greet_user" in main_function_names, "LSP should detect function keyword syntax"
+        assert "process_items" in main_function_names, "LSP should detect function keyword syntax"
+
+        # Verify all expected utils functions are detected by LSP
+        expected_utils = [
+            "to_uppercase",
+            "to_lowercase",
+            "trim_whitespace",
+            "backup_file",
+            "contains_element",
+            "log_message",
+            "is_valid_email",
+            "is_number",
+        ]
+
+        for expected_func in expected_utils:
+            assert expected_func in utils_function_names, f"LSP should detect {expected_func} function"
+
+        # Verify total counts match expectations
+        assert len(main_functions) >= 3, f"Should find at least 3 functions in main.sh, found {len(main_functions)}"
+        assert len(utils_functions) >= 8, f"Should find at least 8 functions in utils.sh, found {len(utils_functions)}"

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

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+from solidlsp.language_servers.clojure_lsp import verify_clojure_cli
+
+
+def _test_clojure_cli() -> bool:
+    try:
+        verify_clojure_cli()
+        return False
+    except (FileNotFoundError, RuntimeError):
+        return True
+
+
+CLI_FAIL = _test_clojure_cli()
+TEST_APP_PATH = Path("src") / "test_app"
+CORE_PATH = str(TEST_APP_PATH / "core.clj")
+UTILS_PATH = str(TEST_APP_PATH / "utils.clj")

projects/ui/serena-new/test/solidlsp/clojure/test_clojure_basic.py

@@ -0,0 +1,222 @@
+import pytest
+
+from serena.project import Project
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import UnifiedSymbolInformation
+
+from . import CLI_FAIL, CORE_PATH, UTILS_PATH
+
+
+@pytest.mark.clojure
+@pytest.mark.skipif(CLI_FAIL, reason=f"Clojure CLI not available: {CLI_FAIL}")
+class TestLanguageServerBasics:
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_basic_definition(self, language_server: SolidLanguageServer):
+        """
+        Test finding definition of 'greet' function call in core.clj
+        """
+        result = language_server.request_definition(CORE_PATH, 20, 12)  # Position of 'greet' in (greet "World")
+
+        assert isinstance(result, list)
+        assert len(result) >= 1
+
+        definition = result[0]
+        assert definition["relativePath"] == CORE_PATH
+        assert definition["range"]["start"]["line"] == 2, "Should find the definition of greet function at line 2"
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_cross_file_references(self, language_server: SolidLanguageServer):
+        """
+        Test finding references to 'multiply' function from core.clj
+        """
+        result = language_server.request_references(CORE_PATH, 12, 6)
+
+        assert isinstance(result, list) and len(result) >= 2, "Should find definition + usage in utils.clj"
+
+        usage_found = any(
+            item["relativePath"] == UTILS_PATH and item["range"]["start"]["line"] == 6  # multiply usage in calculate-area
+            for item in result
+        )
+        assert usage_found, "Should find multiply usage in utils.clj"
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_completions(self, language_server: SolidLanguageServer):
+        with language_server.open_file(UTILS_PATH):
+            # After "core/" in calculate-area
+            result = language_server.request_completions(UTILS_PATH, 6, 8)
+
+            assert isinstance(result, list) and len(result) > 0
+
+            completion_texts = [item["completionText"] for item in result]
+            assert any("multiply" in text for text in completion_texts), "Should find 'multiply' function in completions after 'core/'"
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_document_symbols(self, language_server: SolidLanguageServer):
+        symbols, _ = language_server.request_document_symbols(CORE_PATH)
+
+        assert isinstance(symbols, list) and len(symbols) >= 4, "greet, add, multiply, -main functions"
+
+        # Check that we find the expected function symbols
+        symbol_names = [symbol["name"] for symbol in symbols]
+        expected_functions = ["greet", "add", "multiply", "-main"]
+
+        for func_name in expected_functions:
+            assert func_name in symbol_names, f"Should find {func_name} function in symbols"
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_hover(self, language_server: SolidLanguageServer):
+        """Test hover on greet function"""
+        result = language_server.request_hover(CORE_PATH, 2, 7)
+
+        assert result is not None, "Hover should return information for greet function"
+        assert "contents" in result
+        # Should contain function signature or documentation
+        contents = result["contents"]
+        if isinstance(contents, str):
+            assert "greet" in contents.lower()
+        elif isinstance(contents, dict) and "value" in contents:
+            assert "greet" in contents["value"].lower()
+        else:
+            assert False, f"Unexpected contents format: {type(contents)}"
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_workspace_symbols(self, language_server: SolidLanguageServer):
+        # Search for functions containing "add"
+        result = language_server.request_workspace_symbol("add")
+
+        assert isinstance(result, list) and len(result) > 0, "Should find at least one symbol containing 'add'"
+
+        # Should find the 'add' function
+        symbol_names = [symbol["name"] for symbol in result]
+        assert any("add" in name.lower() for name in symbol_names), f"Should find 'add' function in symbols: {symbol_names}"
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_namespace_functions(self, language_server: SolidLanguageServer):
+        """Test definition lookup for core/greet usage in utils.clj"""
+        # Position of 'greet' in core/greet call
+        result = language_server.request_definition(UTILS_PATH, 11, 25)
+
+        assert isinstance(result, list)
+        assert len(result) >= 1
+
+        definition = result[0]
+        assert definition["relativePath"] == CORE_PATH, "Should find the definition of greet in core.clj"
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_request_references_with_content(self, language_server: SolidLanguageServer):
+        """Test references to multiply function with content"""
+        references = language_server.request_references(CORE_PATH, 12, 6)
+        result = [
+            language_server.retrieve_content_around_line(ref1["relativePath"], ref1["range"]["start"]["line"], 3, 0) for ref1 in references
+        ]
+
+        assert result is not None, "Should find references with content"
+        assert isinstance(result, list)
+        assert len(result) >= 2, "Should find definition + usage in utils.clj"
+
+        for ref in result:
+            assert ref.source_file_path is not None, "Each reference should have a source file path"
+            content_str = ref.to_display_string()
+            assert len(content_str) > 0, "Content should not be empty"
+
+        # Verify we find the reference in utils.clj with context
+        utils_refs = [ref for ref in result if ref.source_file_path and "utils.clj" in ref.source_file_path]
+        assert len(utils_refs) > 0, "Should find reference in utils.clj"
+
+        # The context should contain the calculate-area function
+        utils_content = utils_refs[0].to_display_string()
+        assert "calculate-area" in utils_content
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_request_full_symbol_tree(self, language_server: SolidLanguageServer):
+        """Test retrieving the full symbol tree for project overview
+        We just check that we find some expected symbols.
+        """
+        result = language_server.request_full_symbol_tree()
+
+        assert result is not None, "Should return symbol tree"
+        assert isinstance(result, list), "Symbol tree should be a list"
+        assert len(result) > 0, "Should find symbols in the project"
+
+        def traverse_symbols(symbols, indent=0):
+            """Recursively traverse symbols to print their structure"""
+            info = []
+            for s in symbols:
+                name = getattr(s, "name", "NO_NAME")
+                kind = getattr(s, "kind", "NO_KIND")
+                info.append(f"{' ' * indent}Symbol: {name}, Kind: {kind}")
+                if hasattr(s, "children") and s.children:
+                    info.append(" " * indent + "Children:")
+                    info.extend(traverse_symbols(s.children, indent + 2))
+            return info
+
+        def list_all_symbols(symbols: list[UnifiedSymbolInformation]):
+            found = []
+            for symbol in symbols:
+                found.append(symbol["name"])
+                found.extend(list_all_symbols(symbol["children"]))
+            return found
+
+        all_symbol_names = list_all_symbols(result)
+
+        expected_symbols = ["greet", "add", "multiply", "-main", "calculate-area", "format-greeting", "sum-list"]
+        found_expected = [name for name in expected_symbols if any(name in symbol_name for symbol_name in all_symbol_names)]
+
+        if len(found_expected) < 7:
+            pytest.fail(
+                f"Expected to find at least 3 symbols from {expected_symbols}, but found: {found_expected}.\n"
+                f"All symbol names: {all_symbol_names}\n"
+                f"Symbol tree structure:\n{traverse_symbols(result)}"
+            )
+
+    @pytest.mark.parametrize("language_server", [Language.CLOJURE], indirect=True)
+    def test_request_referencing_symbols(self, language_server: SolidLanguageServer):
+        """Test finding symbols that reference a given symbol
+        Finds references to the 'multiply' function.
+        """
+        result = language_server.request_referencing_symbols(CORE_PATH, 12, 6)
+        assert isinstance(result, list) and len(result) > 0, "Should find at least one referencing symbol"
+        found_relevant_references = False
+        for ref in result:
+            if hasattr(ref, "symbol") and "calculate-area" in ref.symbol["name"]:
+                found_relevant_references = True
+                break
+
+        assert found_relevant_references, f"Should have found calculate-area referencing multiply, but got: {result}"
+
+
+class TestProjectBasics:
+    @pytest.mark.parametrize("project", [Language.CLOJURE], indirect=True)
+    def test_retrieve_content_around_line(self, project: Project):
+        """Test retrieving content around specific lines"""
+        # Test retrieving content around the greet function definition (line 2)
+        result = project.retrieve_content_around_line(CORE_PATH, 2, 2)
+
+        assert result is not None, "Should retrieve content around line 2"
+        content_str = result.to_display_string()
+        assert "greet" in content_str, "Should contain the greet function definition"
+        assert "defn" in content_str, "Should contain defn keyword"
+
+        # Test retrieving content around multiply function (around line 13)
+        result = project.retrieve_content_around_line(CORE_PATH, 13, 1)
+
+        assert result is not None, "Should retrieve content around line 13"
+        content_str = result.to_display_string()
+        assert "multiply" in content_str, "Should contain multiply function"
+
+    @pytest.mark.parametrize("project", [Language.CLOJURE], indirect=True)
+    def test_search_files_for_pattern(self, project: Project) -> None:
+        result = project.search_source_files_for_pattern("defn.*greet")
+
+        assert result is not None, "Pattern search should return results"
+        assert len(result) > 0, "Should find at least one match for 'defn.*greet'"
+
+        core_matches = [match for match in result if match.source_file_path and "core.clj" in match.source_file_path]
+        assert len(core_matches) > 0, "Should find greet function in core.clj"
+
+        result = project.search_source_files_for_pattern(":require")
+
+        assert result is not None, "Should find require statements"
+        utils_matches = [match for match in result if match.source_file_path and "utils.clj" in match.source_file_path]
+        assert len(utils_matches) > 0, "Should find require statement in utils.clj"

projects/ui/serena-new/test/solidlsp/csharp/test_csharp_basic.py

@@ -0,0 +1,307 @@
+import os
+import tempfile
+from pathlib import Path
+from typing import cast
+from unittest.mock import Mock, patch
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.language_servers.csharp_language_server import (
+    CSharpLanguageServer,
+    breadth_first_file_scan,
+    find_solution_or_project_file,
+)
+from solidlsp.ls_config import Language, LanguageServerConfig
+from solidlsp.ls_utils import SymbolUtils
+from solidlsp.settings import SolidLSPSettings
+
+
+@pytest.mark.csharp
+class TestCSharpLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.CSHARP], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        """Test finding symbols in the full symbol tree."""
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Program"), "Program class not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Calculator"), "Calculator class not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Add"), "Add method not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.CSHARP], indirect=True)
+    def test_get_document_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test getting document symbols from a C# file."""
+        file_path = os.path.join("Program.cs")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Check that we have symbols
+        assert len(symbols) > 0
+
+        # Flatten the symbols if they're nested
+        if isinstance(symbols[0], list):
+            symbols = symbols[0]
+
+        # Look for expected classes
+        class_names = [s.get("name") for s in symbols if s.get("kind") == 5]  # 5 is class
+        assert "Program" in class_names
+        assert "Calculator" in class_names
+
+    @pytest.mark.parametrize("language_server", [Language.CSHARP], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references using symbol selection range."""
+        file_path = os.path.join("Program.cs")
+        symbols = language_server.request_document_symbols(file_path)
+        add_symbol = None
+        # Handle nested symbol structure
+        symbol_list = symbols[0] if symbols and isinstance(symbols[0], list) else symbols
+        for sym in symbol_list:
+            if sym.get("name") == "Add":
+                add_symbol = sym
+                break
+        assert add_symbol is not None, "Could not find 'Add' method symbol in Program.cs"
+        sel_start = add_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"] + 1)
+        assert any(
+            "Program.cs" in ref.get("relativePath", "") for ref in refs
+        ), "Program.cs should reference Add method (tried all positions in selectionRange)"
+
+    @pytest.mark.parametrize("language_server", [Language.CSHARP], indirect=True)
+    def test_nested_namespace_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test getting symbols from nested namespace."""
+        file_path = os.path.join("Models", "Person.cs")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Check that we have symbols
+        assert len(symbols) > 0
+
+        # Flatten the symbols if they're nested
+        if isinstance(symbols[0], list):
+            symbols = symbols[0]
+
+        # Check that we have the Person class
+        assert any(s.get("name") == "Person" and s.get("kind") == 5 for s in symbols)
+
+        # Check for properties and methods
+        symbol_names = [s.get("name") for s in symbols]
+        assert "Name" in symbol_names
+        assert "Age" in symbol_names
+        assert "Email" in symbol_names
+        assert "ToString" in symbol_names
+        assert "IsAdult" in symbol_names
+
+    @pytest.mark.parametrize("language_server", [Language.CSHARP], indirect=True)
+    def test_find_referencing_symbols_across_files(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references to Calculator.Subtract method across files."""
+        # First, find the Subtract method in Program.cs
+        file_path = os.path.join("Program.cs")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Flatten the symbols if they're nested
+        symbol_list = symbols[0] if symbols and isinstance(symbols[0], list) else symbols
+
+        subtract_symbol = None
+        for sym in symbol_list:
+            if sym.get("name") == "Subtract":
+                subtract_symbol = sym
+                break
+
+        assert subtract_symbol is not None, "Could not find 'Subtract' method symbol in Program.cs"
+
+        # Get references to the Subtract method
+        sel_start = subtract_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"] + 1)
+
+        # Should find references in both Program.cs and Models/Person.cs
+        ref_files = cast(list[str], [ref.get("relativePath", "") for ref in refs])
+        print(f"Found references: {refs}")
+        print(f"Reference files: {ref_files}")
+
+        # Check that we have references from both files
+        assert any("Program.cs" in ref_file for ref_file in ref_files), "Should find reference in Program.cs"
+        assert any(
+            os.path.join("Models", "Person.cs") in ref_file for ref_file in ref_files
+        ), "Should find reference in Models/Person.cs where Calculator.Subtract is called"
+
+        # check for a second time, since the first call may trigger initialization and change the state of the LS
+        refs_second_call = language_server.request_references(file_path, sel_start["line"], sel_start["character"] + 1)
+        assert refs_second_call == refs, "Second call to request_references should return the same results"
+
+
+@pytest.mark.csharp
+class TestCSharpSolutionProjectOpening:
+    """Test C# language server solution and project opening functionality."""
+
+    def test_breadth_first_file_scan(self):
+        """Test that breadth_first_file_scan finds files in breadth-first order."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create test directory structure
+            (temp_path / "file1.txt").touch()
+            (temp_path / "subdir1").mkdir()
+            (temp_path / "subdir1" / "file2.txt").touch()
+            (temp_path / "subdir2").mkdir()
+            (temp_path / "subdir2" / "file3.txt").touch()
+            (temp_path / "subdir1" / "subdir3").mkdir()
+            (temp_path / "subdir1" / "subdir3" / "file4.txt").touch()
+
+            # Scan files
+            files = list(breadth_first_file_scan(str(temp_path)))
+            filenames = [os.path.basename(f) for f in files]
+
+            # Should find all files
+            assert len(files) == 4
+            assert "file1.txt" in filenames
+            assert "file2.txt" in filenames
+            assert "file3.txt" in filenames
+            assert "file4.txt" in filenames
+
+            # file1.txt should be found first (breadth-first)
+            assert filenames[0] == "file1.txt"
+
+    def test_find_solution_or_project_file_with_solution(self):
+        """Test that find_solution_or_project_file prefers .sln files."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create both .sln and .csproj files
+            solution_file = temp_path / "MySolution.sln"
+            project_file = temp_path / "MyProject.csproj"
+            solution_file.touch()
+            project_file.touch()
+
+            result = find_solution_or_project_file(str(temp_path))
+
+            # Should prefer .sln file
+            assert result == str(solution_file)
+
+    def test_find_solution_or_project_file_with_project_only(self):
+        """Test that find_solution_or_project_file falls back to .csproj files."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create only .csproj file
+            project_file = temp_path / "MyProject.csproj"
+            project_file.touch()
+
+            result = find_solution_or_project_file(str(temp_path))
+
+            # Should return .csproj file
+            assert result == str(project_file)
+
+    def test_find_solution_or_project_file_with_nested_files(self):
+        """Test that find_solution_or_project_file finds files in subdirectories."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create nested structure
+            (temp_path / "src").mkdir()
+            solution_file = temp_path / "src" / "MySolution.sln"
+            solution_file.touch()
+
+            result = find_solution_or_project_file(str(temp_path))
+
+            # Should find nested .sln file
+            assert result == str(solution_file)
+
+    def test_find_solution_or_project_file_returns_none_when_no_files(self):
+        """Test that find_solution_or_project_file returns None when no .sln or .csproj files exist."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create some other files
+            (temp_path / "readme.txt").touch()
+            (temp_path / "other.cs").touch()
+
+            result = find_solution_or_project_file(str(temp_path))
+
+            # Should return None
+            assert result is None
+
+    def test_find_solution_or_project_file_prefers_solution_breadth_first(self):
+        """Test that solution files are preferred even when deeper in the tree."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create .csproj at root and .sln in subdirectory
+            project_file = temp_path / "MyProject.csproj"
+            project_file.touch()
+
+            (temp_path / "src").mkdir()
+            solution_file = temp_path / "src" / "MySolution.sln"
+            solution_file.touch()
+
+            result = find_solution_or_project_file(str(temp_path))
+
+            # Should still prefer .sln file even though it's deeper
+            assert result == str(solution_file)
+
+    @patch("solidlsp.language_servers.csharp_language_server.CSharpLanguageServer._ensure_server_installed")
+    @patch("solidlsp.language_servers.csharp_language_server.CSharpLanguageServer._start_server")
+    def test_csharp_language_server_logs_solution_discovery(self, mock_start_server, mock_ensure_server_installed):
+        """Test that CSharpLanguageServer logs solution/project discovery during initialization."""
+        mock_ensure_server_installed.return_value = ("/usr/bin/dotnet", "/path/to/server.dll")
+
+        # Create test directory with solution file
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            solution_file = temp_path / "TestSolution.sln"
+            solution_file.touch()
+
+            # Mock logger to capture log messages
+            mock_logger = Mock()
+            mock_config = Mock(spec=LanguageServerConfig)
+            mock_config.ignored_paths = []
+
+            # Create CSharpLanguageServer instance
+            mock_settings = Mock(spec=SolidLSPSettings)
+            mock_settings.ls_resources_dir = "/tmp/test_ls_resources"
+            mock_settings.project_data_relative_path = "project_data"
+            CSharpLanguageServer(mock_config, mock_logger, str(temp_path), mock_settings)
+
+            # Verify that logger was called with solution file discovery
+            mock_logger.log.assert_any_call(f"Found solution/project file: {solution_file}", 20)  # logging.INFO
+
+    @patch("solidlsp.language_servers.csharp_language_server.CSharpLanguageServer._ensure_server_installed")
+    @patch("solidlsp.language_servers.csharp_language_server.CSharpLanguageServer._start_server")
+    def test_csharp_language_server_logs_no_solution_warning(self, mock_start_server, mock_ensure_server_installed):
+        """Test that CSharpLanguageServer logs warning when no solution/project files are found."""
+        # Mock the server installation
+        mock_ensure_server_installed.return_value = ("/usr/bin/dotnet", "/path/to/server.dll")
+
+        # Create empty test directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Mock logger to capture log messages
+            mock_logger = Mock()
+            mock_config = Mock(spec=LanguageServerConfig)
+            mock_config.ignored_paths = []
+
+            # Create CSharpLanguageServer instance
+            mock_settings = Mock(spec=SolidLSPSettings)
+            mock_settings.ls_resources_dir = "/tmp/test_ls_resources"
+            mock_settings.project_data_relative_path = "project_data"
+            CSharpLanguageServer(mock_config, mock_logger, str(temp_path), mock_settings)
+
+            # Verify that logger was called with warning about no solution/project files
+            mock_logger.log.assert_any_call(
+                "No .sln or .csproj file found, language server will attempt auto-discovery", 30  # logging.WARNING
+            )
+
+    def test_solution_and_project_opening_with_real_test_repo(self):
+        """Test solution and project opening with the actual C# test repository."""
+        # Get the C# test repo path
+        test_repo_path = Path(__file__).parent.parent.parent / "resources" / "repos" / "csharp" / "test_repo"
+
+        if not test_repo_path.exists():
+            pytest.skip("C# test repository not found")
+
+        # Test solution/project discovery in the real test repo
+        result = find_solution_or_project_file(str(test_repo_path))
+
+        # Should find either .sln or .csproj file
+        assert result is not None
+        assert result.endswith((".sln", ".csproj"))
+
+        # Verify the file actually exists
+        assert os.path.exists(result)

projects/ui/serena-new/test/solidlsp/dart/test_dart_basic.py

@@ -0,0 +1,357 @@
+import os
+from pathlib import Path
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import SymbolKind
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.dart
+class TestDartLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.DART], indirect=True)
+    def test_ls_is_running(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test that the language server starts and stops successfully."""
+        # The fixture already handles start and stop
+        assert language_server.is_running()
+        assert Path(language_server.language_server.repository_root_path).resolve() == repo_path.resolve()
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.DART], indirect=True)
+    def test_find_definition_within_file(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test finding definition of a method within the same file."""
+        # In lib/main.dart:
+        # Line 105: final result1 = calc.add(5, 3); // Reference to add method
+        # Line 12: int add(int a, int b) {        // Definition of add method
+        # Find definition of 'add' method from its usage
+        main_dart_path = str(repo_path / "lib" / "main.dart")
+
+        # Position: calc.add(5, 3) - cursor on 'add'
+        # Line 105 (1-indexed) = line 104 (0-indexed), char position around 22
+        definition_location_list = language_server.request_definition(main_dart_path, 104, 22)
+
+        assert definition_location_list, f"Expected non-empty definition_location_list but got {definition_location_list=}"
+        assert len(definition_location_list) >= 1
+        definition_location = definition_location_list[0]
+        assert definition_location["uri"].endswith("main.dart")
+        # Definition of add method should be around line 11 (0-indexed)
+        # But language server may return different positions
+        assert definition_location["range"]["start"]["line"] >= 0
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.DART], indirect=True)
+    def test_find_definition_across_files(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test finding definition across different files."""
+        # Test finding definition of MathHelper class which is in helper.dart
+        # In lib/main.dart line 50: MathHelper.power(step1, 2)
+        main_dart_path = str(repo_path / "lib" / "main.dart")
+
+        # Position: MathHelper.power(step1, 2) - cursor on 'MathHelper'
+        # Line 50 (1-indexed) = line 49 (0-indexed), char position around 18
+        definition_location_list = language_server.request_definition(main_dart_path, 49, 18)
+
+        # Skip the test if language server doesn't find cross-file references
+        # This is acceptable for a basic test - the important thing is that LS is working
+        if not definition_location_list:
+            pytest.skip("Language server doesn't support cross-file definition lookup for this case")
+
+        assert len(definition_location_list) >= 1
+        definition_location = definition_location_list[0]
+        assert definition_location["uri"].endswith("helper.dart")
+        assert definition_location["range"]["start"]["line"] >= 0
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.DART], indirect=True)
+    def test_find_definition_class_method(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test finding definition of a class method."""
+        # In lib/main.dart:
+        # Line 50: final step2 = MathHelper.power(step1, 2); // Reference to MathHelper.power method
+        # In lib/helper.dart:
+        # Line 14: static double power(double base, int exponent) { // Definition of power method
+        main_dart_path = str(repo_path / "lib" / "main.dart")
+
+        # Position: MathHelper.power(step1, 2) - cursor on 'power'
+        # Line 50 (1-indexed) = line 49 (0-indexed), char position around 30
+        definition_location_list = language_server.request_definition(main_dart_path, 49, 30)
+
+        assert definition_location_list, f"Expected non-empty definition_location_list but got {definition_location_list=}"
+        assert len(definition_location_list) >= 1
+        definition_location = definition_location_list[0]
+        assert definition_location["uri"].endswith("helper.dart")
+        # Definition of power method should be around line 13 (0-indexed)
+        assert 12 <= definition_location["range"]["start"]["line"] <= 16
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.DART], indirect=True)
+    def test_find_references_within_file(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test finding references to a method within the same file."""
+        main_dart_path = str(repo_path / "lib" / "main.dart")
+
+        # Find references to the 'add' method from its definition
+        # Line 12: int add(int a, int b) { // Definition of add method
+        # Line 105: final result1 = calc.add(5, 3); // Usage of add method
+        references = language_server.request_references(main_dart_path, 11, 6)  # cursor on 'add' in definition
+
+        assert references, f"Expected non-empty references but got {references=}"
+        # Should find at least the usage of add method
+        assert len(references) >= 1
+
+        # Check that we have a reference in main.dart
+        main_dart_references = [ref for ref in references if ref["uri"].endswith("main.dart")]
+        assert len(main_dart_references) >= 1
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.DART], indirect=True)
+    def test_find_references_across_files(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test finding references across different files."""
+        helper_dart_path = str(repo_path / "lib" / "helper.dart")
+
+        # Find references to the 'subtract' function from its definition in helper.dart
+        # Definition is in helper.dart, usage is in main.dart
+        references = language_server.request_references(helper_dart_path, 4, 4)  # cursor on 'subtract' in definition
+
+        assert references, f"Expected non-empty references for subtract function but got {references=}"
+
+        # Should find references in main.dart
+        main_dart_references = [ref for ref in references if ref["uri"].endswith("main.dart")]
+        assert len(main_dart_references) >= 1
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.DART], indirect=True)
+    def test_find_definition_constructor(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test finding definition of a constructor call."""
+        main_dart_path = str(repo_path / "lib" / "main.dart")
+
+        # In lib/main.dart:
+        # Line 104: final calc = Calculator(); // Reference to Calculator constructor
+        # Line 4: class Calculator {          // Definition of Calculator class
+        definition_location_list = language_server.request_definition(main_dart_path, 103, 18)  # cursor on 'Calculator'
+
+        assert definition_location_list, f"Expected non-empty definition_location_list but got {definition_location_list=}"
+        assert len(definition_location_list) >= 1
+        definition_location = definition_location_list[0]
+        assert definition_location["uri"].endswith("main.dart")
+        # Definition of Calculator class should be around line 3 (0-indexed)
+        assert 3 <= definition_location["range"]["start"]["line"] <= 7
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.DART], indirect=True)
+    def test_find_definition_import(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test finding definition through imports."""
+        models_dart_path = str(repo_path / "lib" / "models.dart")
+
+        # Test finding definition of User class name where it's used
+        # In lib/models.dart line 27 (constructor): User(this.id, this.name, this.email, this._age);
+        definition_location_list = language_server.request_definition(models_dart_path, 26, 2)  # cursor on 'User' in constructor
+
+        # Skip if language server doesn't find definition in this case
+        if not definition_location_list:
+            pytest.skip("Language server doesn't support definition lookup for this case")
+
+        assert len(definition_location_list) >= 1
+        definition_location = definition_location_list[0]
+        # Language server might return SDK files instead of local files
+        # This is acceptable behavior - the important thing is that it found a definition
+        assert "dart" in definition_location["uri"].lower()
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        """Test finding symbols in the full symbol tree."""
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Calculator"), "Calculator class not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "add"), "add method not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "subtract"), "subtract function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "MathHelper"), "MathHelper class not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "User"), "User class not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references using symbol selection range."""
+        file_path = os.path.join("lib", "main.dart")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Handle nested symbol structure - symbols can be nested in lists
+        symbol_list = symbols[0] if symbols and isinstance(symbols[0], list) else symbols
+
+        # Find the 'add' method symbol in Calculator class
+        add_symbol = None
+        for sym in symbol_list:
+            if sym.get("name") == "add":
+                add_symbol = sym
+                break
+            # Check for nested symbols (methods inside classes)
+            if "children" in sym and sym.get("name") == "Calculator":
+                for child in sym["children"]:
+                    if child.get("name") == "add":
+                        add_symbol = child
+                        break
+                if add_symbol:
+                    break
+
+        assert add_symbol is not None, "Could not find 'add' method symbol in main.dart"
+        sel_start = add_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+
+        # Check that we found references - at least one should be in main.dart
+        assert any(
+            "main.dart" in ref.get("relativePath", "") or "main.dart" in ref.get("uri", "") for ref in refs
+        ), "main.dart should reference add method (tried all positions in selectionRange)"
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_request_containing_symbol_method(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a method."""
+        file_path = os.path.join("lib", "main.dart")
+        # Line 14 is inside the add method body (around 'final result = a + b;')
+        containing_symbol = language_server.request_containing_symbol(file_path, 13, 10, include_body=True)
+
+        # Verify that we found the containing symbol
+        if containing_symbol is not None:
+            assert containing_symbol["name"] == "add"
+            assert containing_symbol["kind"] == SymbolKind.Method
+            if "body" in containing_symbol:
+                assert "add" in containing_symbol["body"] or "final result" in containing_symbol["body"]
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_request_containing_symbol_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a class."""
+        file_path = os.path.join("lib", "main.dart")
+        # Line 4 is the Calculator class definition line
+        containing_symbol = language_server.request_containing_symbol(file_path, 4, 6)
+
+        # Verify that we found the containing symbol
+        if containing_symbol is not None:
+            assert containing_symbol["name"] == "Calculator"
+            assert containing_symbol["kind"] == SymbolKind.Class
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_request_containing_symbol_nested(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol with nested scopes."""
+        file_path = os.path.join("lib", "main.dart")
+        # Line 14 is inside the add method inside Calculator class
+        containing_symbol = language_server.request_containing_symbol(file_path, 13, 20)
+
+        # Verify that we found the innermost containing symbol (the method)
+        if containing_symbol is not None:
+            assert containing_symbol["name"] == "add"
+            assert containing_symbol["kind"] == SymbolKind.Method
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_request_defining_symbol_variable(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a variable usage."""
+        file_path = os.path.join("lib", "main.dart")
+        # Line 14 contains 'final result = a + b;' - test position on 'result'
+        defining_symbol = language_server.request_defining_symbol(file_path, 13, 10)
+
+        # The defining symbol might be the variable itself or the containing method
+        # This is acceptable behavior - different language servers handle this differently
+        if defining_symbol is not None:
+            assert defining_symbol.get("name") in ["result", "add"]
+            if defining_symbol.get("name") == "add":
+                assert defining_symbol.get("kind") == SymbolKind.Method.value
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_request_defining_symbol_imported_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for an imported class/function."""
+        file_path = os.path.join("lib", "main.dart")
+        # Line 20 references 'subtract' which was imported from helper.dart
+        defining_symbol = language_server.request_defining_symbol(file_path, 19, 18)
+
+        # Verify that we found the defining symbol - this should be the subtract function from helper.dart
+        if defining_symbol is not None:
+            assert defining_symbol.get("name") == "subtract"
+            # Could be Function or Method depending on language server interpretation
+            assert defining_symbol.get("kind") in [SymbolKind.Function.value, SymbolKind.Method.value]
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_request_defining_symbol_class_method(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a static class method."""
+        file_path = os.path.join("lib", "main.dart")
+        # Line 50 references MathHelper.power - test position on 'power'
+        defining_symbol = language_server.request_defining_symbol(file_path, 49, 30)
+
+        # Verify that we found the defining symbol - should be the power method
+        if defining_symbol is not None:
+            assert defining_symbol.get("name") == "power"
+            assert defining_symbol.get("kind") == SymbolKind.Method.value
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_request_document_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test getting document symbols from a Dart file."""
+        file_path = os.path.join("lib", "main.dart")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Check that we have symbols
+        assert len(symbols) > 0
+
+        # Flatten the symbols if they're nested
+        symbol_list = symbols[0] if symbols and isinstance(symbols[0], list) else symbols
+
+        # Look for expected classes and methods
+        symbol_names = [s.get("name") for s in symbol_list]
+        assert "Calculator" in symbol_names
+
+        # Check for nested symbols (methods inside classes) - optional
+        calculator_symbol = next((s for s in symbol_list if s.get("name") == "Calculator"), None)
+        if calculator_symbol and "children" in calculator_symbol and calculator_symbol["children"]:
+            method_names = [child.get("name") for child in calculator_symbol["children"]]
+            # If children are populated, we should find the add method
+            assert "add" in method_names
+        else:
+            # Some language servers may not populate children in document symbols
+            # This is acceptable behavior - the important thing is we found the class
+            pass
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_request_referencing_symbols_comprehensive(self, language_server: SolidLanguageServer) -> None:
+        """Test comprehensive referencing symbols functionality."""
+        file_path = os.path.join("lib", "main.dart")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Handle nested symbol structure
+        symbol_list = symbols[0] if symbols and isinstance(symbols[0], list) else symbols
+
+        # Find Calculator class and test its references
+        calculator_symbol = None
+        for sym in symbol_list:
+            if sym.get("name") == "Calculator":
+                calculator_symbol = sym
+                break
+
+        if calculator_symbol and "selectionRange" in calculator_symbol:
+            sel_start = calculator_symbol["selectionRange"]["start"]
+            refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+
+            # Should find references to Calculator (constructor calls, etc.)
+            if refs:
+                # Verify the structure of referencing symbols
+                for ref in refs:
+                    assert "uri" in ref or "relativePath" in ref
+                    if "range" in ref:
+                        assert "start" in ref["range"]
+                        assert "end" in ref["range"]
+
+    @pytest.mark.parametrize("language_server", [Language.DART], indirect=True)
+    def test_cross_file_symbol_resolution(self, language_server: SolidLanguageServer) -> None:
+        """Test symbol resolution across multiple files."""
+        helper_file_path = os.path.join("lib", "helper.dart")
+
+        # Test finding references to subtract function from helper.dart in main.dart
+        helper_symbols = language_server.request_document_symbols(helper_file_path)
+        symbol_list = helper_symbols[0] if helper_symbols and isinstance(helper_symbols[0], list) else helper_symbols
+
+        subtract_symbol = next((s for s in symbol_list if s.get("name") == "subtract"), None)
+
+        if subtract_symbol and "selectionRange" in subtract_symbol:
+            sel_start = subtract_symbol["selectionRange"]["start"]
+            refs = language_server.request_references(helper_file_path, sel_start["line"], sel_start["character"])
+
+            # Should find references in main.dart
+            main_dart_refs = [ref for ref in refs if "main.dart" in ref.get("uri", "") or "main.dart" in ref.get("relativePath", "")]
+            # Note: This may not always work depending on language server capabilities
+            # So we don't assert - just verify the structure if we get results
+            if main_dart_refs:
+                for ref in main_dart_refs:
+                    assert "range" in ref or "location" in ref

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

@@ -0,0 +1,28 @@
+import platform
+
+
+def _test_nextls_available() -> str:
+    """Test if Next LS is available and return error reason if not."""
+    # Check if we're on Windows (Next LS doesn't support Windows)
+    if platform.system() == "Windows":
+        return "Next LS does not support Windows"
+
+    # Try to import and check Elixir availability
+    try:
+        from solidlsp.language_servers.elixir_tools.elixir_tools import ElixirTools
+
+        # Check if Elixir is installed
+        elixir_version = ElixirTools._get_elixir_version()
+        if not elixir_version:
+            return "Elixir is not installed or not in PATH"
+
+        return ""  # No error, Next LS should be available
+
+    except ImportError as e:
+        return f"Failed to import ElixirTools: {e}"
+    except Exception as e:
+        return f"Error checking Next LS availability: {e}"
+
+
+NEXTLS_UNAVAILABLE_REASON = _test_nextls_available()
+NEXTLS_UNAVAILABLE = bool(NEXTLS_UNAVAILABLE_REASON)

projects/ui/serena-new/test/solidlsp/elixir/conftest.py

@@ -0,0 +1,174 @@
+"""
+Elixir-specific test configuration and fixtures.
+"""
+
+import os
+import subprocess
+import time
+from pathlib import Path
+
+import pytest
+
+
+def ensure_elixir_test_repo_compiled(repo_path: str) -> None:
+    """Ensure the Elixir test repository dependencies are installed and project is compiled.
+
+    Next LS requires the project to be fully compiled and indexed before providing
+    complete references and symbol resolution. This function:
+    1. Installs dependencies via 'mix deps.get'
+    2. Compiles the project via 'mix compile'
+
+    This is essential in CI environments where dependencies aren't pre-installed.
+
+    Args:
+        repo_path: Path to the Elixir project root directory
+
+    """
+    # Check if this looks like an Elixir project
+    mix_file = os.path.join(repo_path, "mix.exs")
+    if not os.path.exists(mix_file):
+        return
+
+    # Check if already compiled (optimization for repeated runs)
+    build_path = os.path.join(repo_path, "_build")
+    deps_path = os.path.join(repo_path, "deps")
+
+    if os.path.exists(build_path) and os.path.exists(deps_path):
+        print(f"Elixir test repository already compiled in {repo_path}")
+        return
+
+    try:
+        print("Installing dependencies and compiling Elixir test repository for optimal Next LS performance...")
+
+        # First, install dependencies with increased timeout for CI
+        print("=" * 60)
+        print("Step 1/2: Installing Elixir dependencies...")
+        print("=" * 60)
+        start_time = time.time()
+
+        deps_result = subprocess.run(
+            ["mix", "deps.get"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=180,
+            check=False,  # 3 minutes for dependency installation (CI can be slow)
+        )
+
+        deps_duration = time.time() - start_time
+        print(f"Dependencies installation completed in {deps_duration:.2f} seconds")
+
+        # Always log the output for transparency
+        if deps_result.stdout.strip():
+            print("Dependencies stdout:")
+            print("-" * 40)
+            print(deps_result.stdout)
+            print("-" * 40)
+
+        if deps_result.stderr.strip():
+            print("Dependencies stderr:")
+            print("-" * 40)
+            print(deps_result.stderr)
+            print("-" * 40)
+
+        if deps_result.returncode != 0:
+            print(f"⚠️  Warning: Dependencies installation failed with exit code {deps_result.returncode}")
+            # Continue anyway - some projects might not have dependencies
+        else:
+            print("✓ Dependencies installed successfully")
+
+        # Then compile the project with increased timeout for CI
+        print("=" * 60)
+        print("Step 2/2: Compiling Elixir project...")
+        print("=" * 60)
+        start_time = time.time()
+
+        compile_result = subprocess.run(
+            ["mix", "compile"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=300,
+            check=False,  # 5 minutes for compilation (Credo compilation can be slow in CI)
+        )
+
+        compile_duration = time.time() - start_time
+        print(f"Compilation completed in {compile_duration:.2f} seconds")
+
+        # Always log the output for transparency
+        if compile_result.stdout.strip():
+            print("Compilation stdout:")
+            print("-" * 40)
+            print(compile_result.stdout)
+            print("-" * 40)
+
+        if compile_result.stderr.strip():
+            print("Compilation stderr:")
+            print("-" * 40)
+            print(compile_result.stderr)
+            print("-" * 40)
+
+        if compile_result.returncode == 0:
+            print(f"✓ Elixir test repository compiled successfully in {repo_path}")
+        else:
+            print(f"⚠️  Warning: Compilation completed with exit code {compile_result.returncode}")
+            # Still continue - warnings are often non-fatal
+
+        print("=" * 60)
+        print(f"Total setup time: {time.time() - (start_time - compile_duration - deps_duration):.2f} seconds")
+        print("=" * 60)
+
+    except subprocess.TimeoutExpired as e:
+        print("=" * 60)
+        print(f"❌ TIMEOUT: Elixir setup timed out after {e.timeout} seconds")
+        print(f"Command: {' '.join(e.cmd)}")
+        print("This may indicate slow CI environment - Next LS may still work but with reduced functionality")
+
+        # Try to get partial output if available
+        if hasattr(e, "stdout") and e.stdout:
+            print("Partial stdout before timeout:")
+            print("-" * 40)
+            print(e.stdout)
+            print("-" * 40)
+        if hasattr(e, "stderr") and e.stderr:
+            print("Partial stderr before timeout:")
+            print("-" * 40)
+            print(e.stderr)
+            print("-" * 40)
+        print("=" * 60)
+
+    except FileNotFoundError:
+        print("❌ ERROR: 'mix' command not found - Elixir test repository may not be compiled")
+        print("Please ensure Elixir is installed and available in PATH")
+    except Exception as e:
+        print(f"❌ ERROR: Failed to prepare Elixir test repository: {e}")
+
+
+@pytest.fixture(scope="session", autouse=True)
+def setup_elixir_test_environment():
+    """Automatically prepare Elixir test environment for all Elixir tests.
+
+    This fixture runs once per test session and automatically:
+    1. Installs dependencies via 'mix deps.get'
+    2. Compiles the Elixir test repository via 'mix compile'
+
+    It uses autouse=True so it runs automatically without needing to be explicitly
+    requested by tests. This ensures Next LS has a fully prepared project to work with.
+
+    Uses generous timeouts (3-5 minutes) to accommodate slow CI environments.
+    All output is logged for transparency and debugging.
+    """
+    # Get the test repo path relative to this conftest.py file
+    test_repo_path = Path(__file__).parent.parent.parent / "resources" / "repos" / "elixir" / "test_repo"
+    ensure_elixir_test_repo_compiled(str(test_repo_path))
+    return str(test_repo_path)
+
+
+@pytest.fixture(scope="session")
+def elixir_test_repo_path(setup_elixir_test_environment):
+    """Get the path to the prepared Elixir test repository.
+
+    This fixture depends on setup_elixir_test_environment to ensure dependencies
+    are installed and compilation has completed before returning the path.
+    """
+    return setup_elixir_test_environment

projects/ui/serena-new/test/solidlsp/elixir/test_elixir_basic.py

@@ -0,0 +1,112 @@
+"""
+Basic integration tests for the Elixir language server functionality.
+
+These tests validate the functionality of the language server APIs
+like request_references using the test repository.
+"""
+
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+from . import NEXTLS_UNAVAILABLE, NEXTLS_UNAVAILABLE_REASON
+
+# These marks will be applied to all tests in this module
+pytestmark = [pytest.mark.elixir, pytest.mark.skipif(NEXTLS_UNAVAILABLE, reason=f"Next LS not available: {NEXTLS_UNAVAILABLE_REASON}")]
+
+
+class TestElixirBasic:
+    """Basic Elixir language server functionality tests."""
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_references_function_definition(self, language_server: SolidLanguageServer):
+        """Test finding references to a function definition."""
+        file_path = os.path.join("lib", "models.ex")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Find the User module's 'new' function
+        user_new_symbol = None
+        for symbol in symbols[0]:  # Top level symbols
+            if symbol.get("name") == "User" and symbol.get("kind") == 2:  # Module
+                for child in symbol.get("children", []):
+                    if child.get("name", "").startswith("def new(") and child.get("kind") == 12:  # Function
+                        user_new_symbol = child
+                        break
+                break
+
+        if not user_new_symbol or "selectionRange" not in user_new_symbol:
+            pytest.skip("User.new function or its selectionRange not found")
+
+        sel_start = user_new_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+
+        assert references is not None
+        assert len(references) > 0
+
+        # Should find at least one reference (the definition itself)
+        found_definition = any(ref["uri"].endswith("models.ex") for ref in references)
+        assert found_definition, "Should find the function definition"
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_references_create_user_function(self, language_server: SolidLanguageServer):
+        """Test finding references to create_user function."""
+        file_path = os.path.join("lib", "services.ex")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Find the UserService module's 'create_user' function
+        create_user_symbol = None
+        for symbol in symbols[0]:  # Top level symbols
+            if symbol.get("name") == "UserService" and symbol.get("kind") == 2:  # Module
+                for child in symbol.get("children", []):
+                    if child.get("name", "").startswith("def create_user(") and child.get("kind") == 12:  # Function
+                        create_user_symbol = child
+                        break
+                break
+
+        if not create_user_symbol or "selectionRange" not in create_user_symbol:
+            pytest.skip("UserService.create_user function or its selectionRange not found")
+
+        sel_start = create_user_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+
+        assert references is not None
+        assert len(references) > 0
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_referencing_symbols_function(self, language_server: SolidLanguageServer):
+        """Test finding symbols that reference a specific function."""
+        file_path = os.path.join("lib", "models.ex")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Find the User module's 'new' function
+        user_new_symbol = None
+        for symbol in symbols[0]:  # Top level symbols
+            if symbol.get("name") == "User" and symbol.get("kind") == 2:  # Module
+                for child in symbol.get("children", []):
+                    if child.get("name", "").startswith("def new(") and child.get("kind") == 12:  # Function
+                        user_new_symbol = child
+                        break
+                break
+
+        if not user_new_symbol or "selectionRange" not in user_new_symbol:
+            pytest.skip("User.new function or its selectionRange not found")
+
+        sel_start = user_new_symbol["selectionRange"]["start"]
+        referencing_symbols = language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+
+        assert referencing_symbols is not None
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_timeout_enumeration_bug(self, language_server: SolidLanguageServer):
+        """Test that enumeration doesn't timeout (regression test)."""
+        # This should complete without timing out
+        symbols = language_server.request_document_symbols("lib/models.ex")
+        assert symbols is not None
+
+        # Test multiple symbol requests in succession
+        for _ in range(3):
+            symbols = language_server.request_document_symbols("lib/services.ex")
+            assert symbols is not None

projects/ui/serena-new/test/solidlsp/elixir/test_elixir_ignored_dirs.py

@@ -0,0 +1,142 @@
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from test.conftest import create_ls
+
+from . import NEXTLS_UNAVAILABLE, NEXTLS_UNAVAILABLE_REASON
+
+# These marks will be applied to all tests in this module
+pytestmark = [pytest.mark.elixir, pytest.mark.skipif(NEXTLS_UNAVAILABLE, reason=f"Next LS not available: {NEXTLS_UNAVAILABLE_REASON}")]
+
+
+@pytest.fixture(scope="module")
+def ls_with_ignored_dirs() -> Generator[SolidLanguageServer, None, None]:
+    """Fixture to set up an LS for the elixir test repo with the 'scripts' directory ignored."""
+    ignored_paths = ["scripts", "ignored_dir"]
+    ls = create_ls(ignored_paths=ignored_paths, language=Language.ELIXIR)
+    ls.start()
+    try:
+        yield ls
+    finally:
+        ls.stop()
+
+
+@pytest.mark.parametrize("ls_with_ignored_dirs", [Language.ELIXIR], indirect=True)
+def test_symbol_tree_ignores_dir(ls_with_ignored_dirs: SolidLanguageServer):
+    """Tests that request_full_symbol_tree ignores the configured directory."""
+    root = ls_with_ignored_dirs.request_full_symbol_tree()[0]
+    root_children = root["children"]
+    children_names = {child["name"] for child in root_children}
+
+    # Should have lib and test directories, but not scripts or ignored_dir
+    expected_dirs = {"lib", "test"}
+    assert expected_dirs.issubset(children_names), f"Expected {expected_dirs} to be in {children_names}"
+    assert "scripts" not in children_names, f"scripts should not be in {children_names}"
+    assert "ignored_dir" not in children_names, f"ignored_dir should not be in {children_names}"
+
+
+@pytest.mark.parametrize("ls_with_ignored_dirs", [Language.ELIXIR], indirect=True)
+def test_find_references_ignores_dir(ls_with_ignored_dirs: SolidLanguageServer):
+    """Tests that find_references ignores the configured directory."""
+    # Location of User struct, which is referenced in scripts and ignored_dir
+    definition_file = "lib/models.ex"
+
+    # Find the User struct definition
+    symbols = ls_with_ignored_dirs.request_document_symbols(definition_file)
+    user_symbol = None
+    for symbol_group in symbols:
+        user_symbol = next((s for s in symbol_group if "User" in s.get("name", "")), None)
+        if user_symbol:
+            break
+
+    if not user_symbol or "selectionRange" not in user_symbol:
+        pytest.skip("User symbol not found for reference testing")
+
+    sel_start = user_symbol["selectionRange"]["start"]
+    references = ls_with_ignored_dirs.request_references(definition_file, sel_start["line"], sel_start["character"])
+
+    # Assert that scripts and ignored_dir do not appear in the references
+    assert not any("scripts" in ref["relativePath"] for ref in references), "scripts should be ignored"
+    assert not any("ignored_dir" in ref["relativePath"] for ref in references), "ignored_dir should be ignored"
+
+
+@pytest.mark.parametrize("repo_path", [Language.ELIXIR], indirect=True)
+def test_refs_and_symbols_with_glob_patterns(repo_path: Path) -> None:
+    """Tests that refs and symbols with glob patterns are ignored."""
+    ignored_paths = ["*cripts", "ignored_*"]  # codespell:ignore cripts
+    ls = create_ls(ignored_paths=ignored_paths, repo_path=str(repo_path), language=Language.ELIXIR)
+    ls.start()
+
+    try:
+        # Same as in the above tests
+        root = ls.request_full_symbol_tree()[0]
+        root_children = root["children"]
+        children_names = {child["name"] for child in root_children}
+
+        # Should have lib and test directories, but not scripts or ignored_dir
+        expected_dirs = {"lib", "test"}
+        assert expected_dirs.issubset(children_names), f"Expected {expected_dirs} to be in {children_names}"
+        assert "scripts" not in children_names, f"scripts should not be in {children_names} (glob pattern)"
+        assert "ignored_dir" not in children_names, f"ignored_dir should not be in {children_names} (glob pattern)"
+
+        # Test that the refs and symbols with glob patterns are ignored
+        definition_file = "lib/models.ex"
+
+        # Find the User struct definition
+        symbols = ls.request_document_symbols(definition_file)
+        user_symbol = None
+        for symbol_group in symbols:
+            user_symbol = next((s for s in symbol_group if "User" in s.get("name", "")), None)
+            if user_symbol:
+                break
+
+        if user_symbol and "selectionRange" in user_symbol:
+            sel_start = user_symbol["selectionRange"]["start"]
+            references = ls.request_references(definition_file, sel_start["line"], sel_start["character"])
+
+            # Assert that scripts and ignored_dir do not appear in references
+            assert not any("scripts" in ref["relativePath"] for ref in references), "scripts should be ignored (glob)"
+            assert not any("ignored_dir" in ref["relativePath"] for ref in references), "ignored_dir should be ignored (glob)"
+    finally:
+        ls.stop()
+
+
+@pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+def test_default_ignored_directories(language_server: SolidLanguageServer):
+    """Test that default Elixir directories are ignored."""
+    # Test that Elixir-specific directories are ignored by default
+    assert language_server.is_ignored_dirname("_build"), "_build should be ignored"
+    assert language_server.is_ignored_dirname("deps"), "deps should be ignored"
+    assert language_server.is_ignored_dirname(".elixir_ls"), ".elixir_ls should be ignored"
+    assert language_server.is_ignored_dirname("cover"), "cover should be ignored"
+    assert language_server.is_ignored_dirname("node_modules"), "node_modules should be ignored"
+
+    # Test that important directories are not ignored
+    assert not language_server.is_ignored_dirname("lib"), "lib should not be ignored"
+    assert not language_server.is_ignored_dirname("test"), "test should not be ignored"
+    assert not language_server.is_ignored_dirname("config"), "config should not be ignored"
+    assert not language_server.is_ignored_dirname("priv"), "priv should not be ignored"
+
+
+@pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+def test_symbol_tree_excludes_build_dirs(language_server: SolidLanguageServer):
+    """Test that symbol tree excludes build and dependency directories."""
+    symbol_tree = language_server.request_full_symbol_tree()
+
+    if symbol_tree:
+        root = symbol_tree[0]
+        children_names = {child["name"] for child in root.get("children", [])}
+
+        # Build and dependency directories should not appear
+        ignored_dirs = {"_build", "deps", ".elixir_ls", "cover", "node_modules"}
+        found_ignored = ignored_dirs.intersection(children_names)
+        assert len(found_ignored) == 0, f"Found ignored directories in symbol tree: {found_ignored}"
+
+        # Important directories should appear
+        important_dirs = {"lib", "test"}
+        found_important = important_dirs.intersection(children_names)
+        assert len(found_important) > 0, f"Expected to find important directories: {important_dirs}, got: {children_names}"

projects/ui/serena-new/test/solidlsp/elixir/test_elixir_integration.py

@@ -0,0 +1,160 @@
+"""
+Integration tests for Elixir language server with test repository.
+
+These tests verify that the language server works correctly with a real Elixir project
+and can perform advanced operations like cross-file symbol resolution.
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+
+from serena.project import Project
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+from . import NEXTLS_UNAVAILABLE, NEXTLS_UNAVAILABLE_REASON
+
+# These marks will be applied to all tests in this module
+pytestmark = [pytest.mark.elixir, pytest.mark.skipif(NEXTLS_UNAVAILABLE, reason=f"Next LS not available: {NEXTLS_UNAVAILABLE_REASON}")]
+
+
+class TestElixirIntegration:
+    """Integration tests for Elixir language server with test repository."""
+
+    @pytest.fixture
+    def elixir_test_repo_path(self):
+        """Get the path to the Elixir test repository."""
+        test_dir = Path(__file__).parent.parent.parent
+        return str(test_dir / "resources" / "repos" / "elixir" / "test_repo")
+
+    def test_elixir_repo_structure(self, elixir_test_repo_path):
+        """Test that the Elixir test repository has the expected structure."""
+        repo_path = Path(elixir_test_repo_path)
+
+        # Check that key files exist
+        assert (repo_path / "mix.exs").exists(), "mix.exs should exist"
+        assert (repo_path / "lib" / "test_repo.ex").exists(), "main module should exist"
+        assert (repo_path / "lib" / "utils.ex").exists(), "utils module should exist"
+        assert (repo_path / "lib" / "models.ex").exists(), "models module should exist"
+        assert (repo_path / "lib" / "services.ex").exists(), "services module should exist"
+        assert (repo_path / "lib" / "examples.ex").exists(), "examples module should exist"
+        assert (repo_path / "test" / "test_repo_test.exs").exists(), "test file should exist"
+        assert (repo_path / "test" / "models_test.exs").exists(), "models test should exist"
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_cross_file_symbol_resolution(self, language_server: SolidLanguageServer):
+        """Test that symbols can be resolved across different files."""
+        # Test that User struct from models.ex can be found when referenced in services.ex
+        services_file = os.path.join("lib", "services.ex")
+
+        # Find where User is referenced in services.ex
+        content = language_server.retrieve_full_file_content(services_file)
+        lines = content.split("\n")
+        user_reference_line = None
+        for i, line in enumerate(lines):
+            if "alias TestRepo.Models.{User" in line:
+                user_reference_line = i
+                break
+
+        if user_reference_line is None:
+            pytest.skip("Could not find User reference in services.ex")
+
+        # Try to find the definition
+        defining_symbol = language_server.request_defining_symbol(services_file, user_reference_line, 30)
+
+        if defining_symbol and "location" in defining_symbol:
+            # Should point to models.ex
+            assert "models.ex" in defining_symbol["location"]["uri"]
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_module_hierarchy_understanding(self, language_server: SolidLanguageServer):
+        """Test that the language server understands Elixir module hierarchy."""
+        models_file = os.path.join("lib", "models.ex")
+        symbols = language_server.request_document_symbols(models_file)
+
+        if symbols:
+            # Flatten symbol structure
+            all_symbols = []
+            for symbol_group in symbols:
+                if isinstance(symbol_group, list):
+                    all_symbols.extend(symbol_group)
+                else:
+                    all_symbols.append(symbol_group)
+
+            symbol_names = [s.get("name", "") for s in all_symbols]
+
+            # Should understand nested module structure
+            expected_modules = ["TestRepo.Models", "User", "Item", "Order"]
+            found_modules = [name for name in expected_modules if any(name in symbol_name for symbol_name in symbol_names)]
+            assert len(found_modules) > 0, f"Expected modules {expected_modules}, found symbols {symbol_names}"
+
+    def test_file_extension_matching(self):
+        """Test that the Elixir language recognizes the correct file extensions."""
+        language = Language.ELIXIR
+        matcher = language.get_source_fn_matcher()
+
+        # Test Elixir file extensions
+        assert matcher.is_relevant_filename("lib/test_repo.ex")
+        assert matcher.is_relevant_filename("test/test_repo_test.exs")
+        assert matcher.is_relevant_filename("config/config.exs")
+        assert matcher.is_relevant_filename("mix.exs")
+        assert matcher.is_relevant_filename("lib/models.ex")
+        assert matcher.is_relevant_filename("lib/services.ex")
+
+        # Test non-Elixir files
+        assert not matcher.is_relevant_filename("README.md")
+        assert not matcher.is_relevant_filename("lib/test_repo.py")
+        assert not matcher.is_relevant_filename("package.json")
+        assert not matcher.is_relevant_filename("Cargo.toml")
+
+
+class TestElixirProject:
+    @pytest.mark.parametrize("project", [Language.ELIXIR], indirect=True)
+    def test_comprehensive_symbol_search(self, project: Project):
+        """Test comprehensive symbol search across the entire project."""
+        # Search for all function definitions
+        function_pattern = r"def\s+\w+\s*[\(\s]"
+        function_matches = project.search_source_files_for_pattern(function_pattern)
+
+        # Should find functions across multiple files
+        if function_matches:
+            files_with_functions = set()
+            for match in function_matches:
+                if match.source_file_path:
+                    files_with_functions.add(os.path.basename(match.source_file_path))
+
+            # Should find functions in multiple files
+            expected_files = {"models.ex", "services.ex", "examples.ex", "utils.ex", "test_repo.ex"}
+            found_files = expected_files.intersection(files_with_functions)
+            assert len(found_files) > 0, f"Expected functions in {expected_files}, found in {files_with_functions}"
+
+        # Search for struct definitions
+        struct_pattern = r"defstruct\s+\["
+        struct_matches = project.search_source_files_for_pattern(struct_pattern)
+
+        if struct_matches:
+            # Should find structs primarily in models.ex
+            models_structs = [m for m in struct_matches if m.source_file_path and "models.ex" in m.source_file_path]
+            assert len(models_structs) > 0, "Should find struct definitions in models.ex"
+
+    @pytest.mark.parametrize("project", [Language.ELIXIR], indirect=True)
+    def test_protocol_and_implementation_understanding(self, project: Project):
+        """Test that the language server understands Elixir protocols and implementations."""
+        # Search for protocol definitions
+        protocol_pattern = r"defprotocol\s+\w+"
+        protocol_matches = project.search_source_files_for_pattern(protocol_pattern, paths_include_glob="**/models.ex")
+
+        if protocol_matches:
+            # Should find the Serializable protocol
+            serializable_matches = [m for m in protocol_matches if "Serializable" in str(m)]
+            assert len(serializable_matches) > 0, "Should find Serializable protocol definition"
+
+        # Search for protocol implementations
+        impl_pattern = r"defimpl\s+\w+"
+        impl_matches = project.search_source_files_for_pattern(impl_pattern, paths_include_glob="**/models.ex")
+
+        if impl_matches:
+            # Should find multiple implementations
+            assert len(impl_matches) >= 3, f"Should find at least 3 protocol implementations, found {len(impl_matches)}"

projects/ui/serena-new/test/solidlsp/elixir/test_elixir_symbol_retrieval.py

@@ -0,0 +1,342 @@
+"""
+Tests for the Elixir language server symbol-related functionality.
+
+These tests focus on the following methods:
+- request_containing_symbol
+- request_referencing_symbols
+- request_defining_symbol
+"""
+
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import SymbolKind
+
+from . import NEXTLS_UNAVAILABLE, NEXTLS_UNAVAILABLE_REASON
+
+# These marks will be applied to all tests in this module
+pytestmark = [pytest.mark.elixir, pytest.mark.skipif(NEXTLS_UNAVAILABLE, reason=f"Next LS not available: {NEXTLS_UNAVAILABLE_REASON}")]
+
+
+class TestElixirLanguageServerSymbols:
+    """Test the Elixir language server's symbol-related functionality."""
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_containing_symbol_function(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a function."""
+        # Test for a position inside the create_user function
+        file_path = os.path.join("lib", "services.ex")
+
+        # Find the create_user function in the file
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        create_user_line = None
+        for i, line in enumerate(lines):
+            if "def create_user(" in line:
+                create_user_line = i + 2  # Go inside the function body
+                break
+
+        if create_user_line is None:
+            pytest.skip("Could not find create_user function")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, create_user_line, 10, include_body=True)
+
+        # Verify that we found the containing symbol
+        if containing_symbol:
+            # Next LS returns the full function signature instead of just the function name
+            assert containing_symbol["name"] == "def create_user(pid, id, name, email, roles \\\\ [])"
+            assert containing_symbol["kind"] == SymbolKind.Method or containing_symbol["kind"] == SymbolKind.Function
+            if "body" in containing_symbol:
+                assert "def create_user" in containing_symbol["body"]
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_containing_symbol_module(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a module."""
+        # Test for a position inside the UserService module but outside any function
+        file_path = os.path.join("lib", "services.ex")
+
+        # Find the UserService module definition
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        user_service_line = None
+        for i, line in enumerate(lines):
+            if "defmodule UserService do" in line:
+                user_service_line = i + 1  # Go inside the module
+                break
+
+        if user_service_line is None:
+            pytest.skip("Could not find UserService module")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, user_service_line, 5)
+
+        # Verify that we found the containing symbol
+        if containing_symbol:
+            assert "UserService" in containing_symbol["name"]
+            assert containing_symbol["kind"] == SymbolKind.Module or containing_symbol["kind"] == SymbolKind.Class
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_containing_symbol_nested(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol with nested scopes."""
+        # Test for a position inside a function which is inside a module
+        file_path = os.path.join("lib", "services.ex")
+
+        # Find a function inside UserService
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        function_body_line = None
+        for i, line in enumerate(lines):
+            if "def create_user(" in line:
+                function_body_line = i + 3  # Go deeper into the function body
+                break
+
+        if function_body_line is None:
+            pytest.skip("Could not find function body")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, function_body_line, 15)
+
+        # Verify that we found the innermost containing symbol (the function)
+        if containing_symbol:
+            expected_names = ["create_user", "UserService"]
+            assert any(name in containing_symbol["name"] for name in expected_names)
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_containing_symbol_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a position with no containing symbol."""
+        # Test for a position outside any function/module (e.g., in module doc)
+        file_path = os.path.join("lib", "services.ex")
+        # Line 1-3 are likely in module documentation or imports
+        containing_symbol = language_server.request_containing_symbol(file_path, 2, 10)
+
+        # Should return None or an empty dictionary, or the top-level module
+        # This is acceptable behavior for module-level positions
+        assert containing_symbol is None or containing_symbol == {} or "TestRepo.Services" in str(containing_symbol)
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_referencing_symbols_struct(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a struct."""
+        # Test referencing symbols for User struct
+        file_path = os.path.join("lib", "models.ex")
+
+        symbols = language_server.request_document_symbols(file_path)
+        user_symbol = None
+        for symbol_group in symbols:
+            user_symbol = next((s for s in symbol_group if "User" in s.get("name", "")), None)
+            if user_symbol:
+                break
+
+        if not user_symbol or "selectionRange" not in user_symbol:
+            pytest.skip("User symbol or its selectionRange not found")
+
+        sel_start = user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+
+        if ref_symbols:
+            services_references = [
+                symbol
+                for symbol in ref_symbols
+                if "location" in symbol and "uri" in symbol["location"] and "services.ex" in symbol["location"]["uri"]
+            ]
+            # We expect some references from services.ex
+            assert len(services_references) >= 0  # At least attempt to find references
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_referencing_symbols_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a position with no symbol."""
+        file_path = os.path.join("lib", "services.ex")
+        # Line 3 is likely a blank line or comment
+        try:
+            ref_symbols = [ref.symbol for ref in language_server.request_referencing_symbols(file_path, 3, 0)]
+            # If we get here, make sure we got an empty result
+            assert ref_symbols == [] or ref_symbols is None
+        except Exception:
+            # The method might raise an exception for invalid positions
+            # which is acceptable behavior
+            pass
+
+    # Tests for request_defining_symbol
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_defining_symbol_function_call(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a function call."""
+        # Find a place where User.new is called in services.ex
+        file_path = os.path.join("lib", "services.ex")
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        user_new_call_line = None
+        for i, line in enumerate(lines):
+            if "User.new(" in line:
+                user_new_call_line = i
+                break
+
+        if user_new_call_line is None:
+            pytest.skip("Could not find User.new call")
+
+        # Try to find the definition of User.new
+        defining_symbol = language_server.request_defining_symbol(file_path, user_new_call_line, 15)
+
+        if defining_symbol:
+            assert defining_symbol.get("name") == "new" or "User" in defining_symbol.get("name", "")
+            if "location" in defining_symbol and "uri" in defining_symbol["location"]:
+                assert "models.ex" in defining_symbol["location"]["uri"]
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_defining_symbol_struct_usage(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a struct usage."""
+        # Find a place where User struct is used in services.ex
+        file_path = os.path.join("lib", "services.ex")
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        user_usage_line = None
+        for i, line in enumerate(lines):
+            if "alias TestRepo.Models.{User" in line:
+                user_usage_line = i
+                break
+
+        if user_usage_line is None:
+            pytest.skip("Could not find User struct usage")
+
+        defining_symbol = language_server.request_defining_symbol(file_path, user_usage_line, 30)
+
+        if defining_symbol:
+            assert "User" in defining_symbol.get("name", "")
+
+    @pytest.mark.xfail(
+        reason="Known intermittent bug in Next LS v0.23.3: Protocol.UndefinedError for :timeout atom. "
+        "Occurs in CI environments but may pass locally. "
+        "See https://github.com/elixir-tools/next-ls/issues/543",
+        strict=False,
+    )
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_defining_symbol_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a position with no symbol."""
+        # Test for a position with no symbol (e.g., whitespace or comment)
+        file_path = os.path.join("lib", "services.ex")
+        # Line 3 is likely a blank line
+        defining_symbol = language_server.request_defining_symbol(file_path, 3, 0)
+
+        # Should return None or empty
+        assert defining_symbol is None or defining_symbol == {}
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_symbol_methods_integration(self, language_server: SolidLanguageServer) -> None:
+        """Test integration between different symbol methods."""
+        file_path = os.path.join("lib", "models.ex")
+
+        # Find User struct definition
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        user_struct_line = None
+        for i, line in enumerate(lines):
+            if "defmodule User do" in line:
+                user_struct_line = i
+                break
+
+        if user_struct_line is None:
+            pytest.skip("Could not find User struct")
+
+        # Test containing symbol
+        containing = language_server.request_containing_symbol(file_path, user_struct_line + 5, 10)
+
+        if containing:
+            # Test that we can find references to this symbol
+            if "location" in containing and "range" in containing["location"]:
+                start_pos = containing["location"]["range"]["start"]
+                refs = [
+                    ref.symbol for ref in language_server.request_referencing_symbols(file_path, start_pos["line"], start_pos["character"])
+                ]
+                # We should find some references or none (both are valid outcomes)
+                assert isinstance(refs, list)
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_symbol_tree_structure(self, language_server: SolidLanguageServer) -> None:
+        """Test that symbol tree structure is correctly built."""
+        symbol_tree = language_server.request_full_symbol_tree()
+
+        # Should get a tree structure
+        assert len(symbol_tree) > 0
+
+        # Should have our test repository structure
+        root = symbol_tree[0]
+        assert "children" in root
+
+        # Look for lib directory
+        lib_dir = None
+        for child in root["children"]:
+            if child["name"] == "lib":
+                lib_dir = child
+                break
+
+        if lib_dir:
+            # Next LS returns module names instead of file names (e.g., 'services' instead of 'services.ex')
+            file_names = [child["name"] for child in lib_dir.get("children", [])]
+            expected_modules = ["models", "services", "examples", "utils", "test_repo"]
+            found_modules = [name for name in expected_modules if name in file_names]
+            assert len(found_modules) > 0, f"Expected to find some modules from {expected_modules}, but got {file_names}"
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_request_dir_overview(self, language_server: SolidLanguageServer) -> None:
+        """Test request_dir_overview functionality."""
+        lib_overview = language_server.request_dir_overview("lib")
+
+        # Should get an overview of the lib directory
+        assert lib_overview is not None
+        # Next LS returns keys like 'lib/services.ex' instead of just 'lib'
+        overview_keys = list(lib_overview.keys()) if hasattr(lib_overview, "keys") else []
+        lib_files = [key for key in overview_keys if key.startswith("lib/")]
+        assert len(lib_files) > 0, f"Expected to find lib/ files in overview keys: {overview_keys}"
+
+        # Should contain information about our modules
+        overview_text = str(lib_overview).lower()
+        expected_terms = ["models", "services", "user", "item"]
+        found_terms = [term for term in expected_terms if term in overview_text]
+        assert len(found_terms) > 0, f"Expected to find some terms from {expected_terms} in overview"
+
+    # @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    # def test_request_document_overview(self, language_server: SolidLanguageServer) -> None:
+    #     """Test request_document_overview functionality."""
+    #     # COMMENTED OUT: Next LS document overview doesn't contain expected terms
+    #     # Next LS return value: [('TestRepo.Models', 2, 0, 0)] - only module info, no detailed content
+    #     # Expected terms like 'user', 'item', 'order', 'struct', 'defmodule' are not present
+    #     # This appears to be a limitation of Next LS document overview functionality
+    #     #
+    #     file_path = os.path.join("lib", "models.ex")
+    #     doc_overview = language_server.request_document_overview(file_path)
+    #
+    #     # Should get an overview of the models.ex file
+    #     assert doc_overview is not None
+    #
+    #     # Should contain information about our structs and functions
+    #     overview_text = str(doc_overview).lower()
+    #     expected_terms = ["user", "item", "order", "struct", "defmodule"]
+    #     found_terms = [term for term in expected_terms if term in overview_text]
+    #     assert len(found_terms) > 0, f"Expected to find some terms from {expected_terms} in overview"
+
+    @pytest.mark.parametrize("language_server", [Language.ELIXIR], indirect=True)
+    def test_containing_symbol_of_module_attribute(self, language_server: SolidLanguageServer) -> None:
+        """Test containing symbol for module attributes."""
+        file_path = os.path.join("lib", "models.ex")
+
+        # Find a module attribute like @type or @doc
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        attribute_line = None
+        for i, line in enumerate(lines):
+            if line.strip().startswith("@type") or line.strip().startswith("@doc"):
+                attribute_line = i
+                break
+
+        if attribute_line is None:
+            pytest.skip("Could not find module attribute")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, attribute_line, 5)
+
+        if containing_symbol:
+            # Should be contained within a module
+            assert "name" in containing_symbol
+            # The containing symbol should be a module
+            expected_names = ["User", "Item", "Order", "TestRepo.Models"]
+            assert any(name in containing_symbol["name"] for name in expected_names)

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

@@ -0,0 +1,33 @@
+import platform
+
+
+def _test_erlang_ls_available() -> str:
+    """Test if Erlang LS is available and return error reason if not."""
+    # Check if we're on Windows (Erlang LS doesn't support Windows)
+    if platform.system() == "Windows":
+        return "Erlang LS does not support Windows"
+
+    # Try to import and check Erlang availability
+    try:
+        from solidlsp.language_servers.erlang_language_server import ErlangLanguageServer
+
+        # Check if Erlang/OTP is installed
+        erlang_version = ErlangLanguageServer._get_erlang_version()
+        if not erlang_version:
+            return "Erlang/OTP is not installed or not in PATH"
+
+        # Check if rebar3 is available (commonly used build tool)
+        rebar3_available = ErlangLanguageServer._check_rebar3_available()
+        if not rebar3_available:
+            return "rebar3 is not installed or not in PATH (required for project compilation)"
+
+        return ""  # No error, Erlang LS should be available
+
+    except ImportError as e:
+        return f"Failed to import ErlangLanguageServer: {e}"
+    except Exception as e:
+        return f"Error checking Erlang LS availability: {e}"
+
+
+ERLANG_LS_UNAVAILABLE_REASON = _test_erlang_ls_available()
+ERLANG_LS_UNAVAILABLE = bool(ERLANG_LS_UNAVAILABLE_REASON)

projects/ui/serena-new/test/solidlsp/erlang/conftest.py

@@ -0,0 +1,174 @@
+"""
+Erlang-specific test configuration and fixtures.
+"""
+
+import os
+import subprocess
+import time
+from pathlib import Path
+
+import pytest
+
+
+def ensure_erlang_test_repo_compiled(repo_path: str) -> None:
+    """Ensure the Erlang test repository dependencies are installed and project is compiled.
+
+    Erlang LS requires the project to be fully compiled and indexed before providing
+    complete references and symbol resolution. This function:
+    1. Installs dependencies via 'rebar3 deps'
+    2. Compiles the project via 'rebar3 compile'
+
+    This is essential in CI environments where dependencies aren't pre-installed.
+
+    Args:
+        repo_path: Path to the Erlang project root directory
+
+    """
+    # Check if this looks like an Erlang project
+    rebar_config = os.path.join(repo_path, "rebar.config")
+    if not os.path.exists(rebar_config):
+        return
+
+    # Check if already compiled (optimization for repeated runs)
+    build_path = os.path.join(repo_path, "_build")
+    deps_path = os.path.join(repo_path, "deps")
+
+    if os.path.exists(build_path) and os.path.exists(deps_path):
+        print(f"Erlang test repository already compiled in {repo_path}")
+        return
+
+    try:
+        print("Installing dependencies and compiling Erlang test repository for optimal Erlang LS performance...")
+
+        # First, install dependencies with increased timeout for CI
+        print("=" * 60)
+        print("Step 1/2: Installing Erlang dependencies...")
+        print("=" * 60)
+        start_time = time.time()
+
+        deps_result = subprocess.run(
+            ["rebar3", "deps"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=180,
+            check=False,  # 3 minutes for dependency installation (CI can be slow)
+        )
+
+        deps_duration = time.time() - start_time
+        print(f"Dependencies installation completed in {deps_duration:.2f} seconds")
+
+        # Always log the output for transparency
+        if deps_result.stdout.strip():
+            print("Dependencies stdout:")
+            print("-" * 40)
+            print(deps_result.stdout)
+            print("-" * 40)
+
+        if deps_result.stderr.strip():
+            print("Dependencies stderr:")
+            print("-" * 40)
+            print(deps_result.stderr)
+            print("-" * 40)
+
+        if deps_result.returncode != 0:
+            print(f"⚠️  Warning: Dependencies installation failed with exit code {deps_result.returncode}")
+            # Continue anyway - some projects might not have dependencies
+        else:
+            print("✓ Dependencies installed successfully")
+
+        # Then compile the project with increased timeout for CI
+        print("=" * 60)
+        print("Step 2/2: Compiling Erlang project...")
+        print("=" * 60)
+        start_time = time.time()
+
+        compile_result = subprocess.run(
+            ["rebar3", "compile"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=300,
+            check=False,  # 5 minutes for compilation (Dialyzer can be slow in CI)
+        )
+
+        compile_duration = time.time() - start_time
+        print(f"Compilation completed in {compile_duration:.2f} seconds")
+
+        # Always log the output for transparency
+        if compile_result.stdout.strip():
+            print("Compilation stdout:")
+            print("-" * 40)
+            print(compile_result.stdout)
+            print("-" * 40)
+
+        if compile_result.stderr.strip():
+            print("Compilation stderr:")
+            print("-" * 40)
+            print(compile_result.stderr)
+            print("-" * 40)
+
+        if compile_result.returncode == 0:
+            print(f"✓ Erlang test repository compiled successfully in {repo_path}")
+        else:
+            print(f"⚠️  Warning: Compilation completed with exit code {compile_result.returncode}")
+            # Still continue - warnings are often non-fatal
+
+        print("=" * 60)
+        print(f"Total setup time: {time.time() - (start_time - compile_duration - deps_duration):.2f} seconds")
+        print("=" * 60)
+
+    except subprocess.TimeoutExpired as e:
+        print("=" * 60)
+        print(f"❌ TIMEOUT: Erlang setup timed out after {e.timeout} seconds")
+        print(f"Command: {' '.join(e.cmd)}")
+        print("This may indicate slow CI environment - Erlang LS may still work but with reduced functionality")
+
+        # Try to get partial output if available
+        if hasattr(e, "stdout") and e.stdout:
+            print("Partial stdout before timeout:")
+            print("-" * 40)
+            print(e.stdout)
+            print("-" * 40)
+        if hasattr(e, "stderr") and e.stderr:
+            print("Partial stderr before timeout:")
+            print("-" * 40)
+            print(e.stderr)
+            print("-" * 40)
+        print("=" * 60)
+
+    except FileNotFoundError:
+        print("❌ ERROR: 'rebar3' command not found - Erlang test repository may not be compiled")
+        print("Please ensure rebar3 is installed and available in PATH")
+    except Exception as e:
+        print(f"❌ ERROR: Failed to prepare Erlang test repository: {e}")
+
+
+@pytest.fixture(scope="session", autouse=True)
+def setup_erlang_test_environment():
+    """Automatically prepare Erlang test environment for all Erlang tests.
+
+    This fixture runs once per test session and automatically:
+    1. Installs dependencies via 'rebar3 deps'
+    2. Compiles the Erlang test repository via 'rebar3 compile'
+
+    It uses autouse=True so it runs automatically without needing to be explicitly
+    requested by tests. This ensures Erlang LS has a fully prepared project to work with.
+
+    Uses generous timeouts (3-5 minutes) to accommodate slow CI environments.
+    All output is logged for transparency and debugging.
+    """
+    # Get the test repo path relative to this conftest.py file
+    test_repo_path = Path(__file__).parent.parent.parent / "resources" / "repos" / "erlang" / "test_repo"
+    ensure_erlang_test_repo_compiled(str(test_repo_path))
+    return str(test_repo_path)
+
+
+@pytest.fixture(scope="session")
+def erlang_test_repo_path(setup_erlang_test_environment):
+    """Get the path to the prepared Erlang test repository.
+
+    This fixture depends on setup_erlang_test_environment to ensure dependencies
+    are installed and compilation has completed before returning the path.
+    """
+    return setup_erlang_test_environment

projects/ui/serena-new/test/solidlsp/erlang/test_erlang_basic.py

@@ -0,0 +1,43 @@
+"""
+Basic integration tests for the Erlang language server functionality.
+
+These tests validate the functionality of the language server APIs
+like request_references using the test repository.
+"""
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+from . import ERLANG_LS_UNAVAILABLE, ERLANG_LS_UNAVAILABLE_REASON
+
+
+@pytest.mark.erlang
+@pytest.mark.skipif(ERLANG_LS_UNAVAILABLE, reason=f"Erlang LS not available: {ERLANG_LS_UNAVAILABLE_REASON}")
+class TestErlangLanguageServerBasics:
+    """Test basic functionality of the Erlang language server."""
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_language_server_initialization(self, language_server: SolidLanguageServer) -> None:
+        """Test that the Erlang language server initializes properly."""
+        assert language_server is not None
+        assert language_server.language == Language.ERLANG
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_document_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test document symbols retrieval for Erlang files."""
+        try:
+            file_path = "hello.erl"
+            symbols_tuple = language_server.request_document_symbols(file_path)
+            assert isinstance(symbols_tuple, tuple)
+            assert len(symbols_tuple) == 2
+
+            all_symbols, root_symbols = symbols_tuple
+            assert isinstance(all_symbols, list)
+            assert isinstance(root_symbols, list)
+        except Exception as e:
+            if "not fully initialized" in str(e):
+                pytest.skip("Erlang language server not fully initialized")
+            else:
+                raise

projects/ui/serena-new/test/solidlsp/erlang/test_erlang_ignored_dirs.py

@@ -0,0 +1,227 @@
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from test.conftest import create_ls
+
+from . import ERLANG_LS_UNAVAILABLE, ERLANG_LS_UNAVAILABLE_REASON
+
+# These marks will be applied to all tests in this module
+pytestmark = [
+    pytest.mark.erlang,
+    pytest.mark.skipif(ERLANG_LS_UNAVAILABLE, reason=f"Erlang LS not available: {ERLANG_LS_UNAVAILABLE_REASON}"),
+]
+
+
+@pytest.fixture(scope="module")
+def ls_with_ignored_dirs() -> Generator[SolidLanguageServer, None, None]:
+    """Fixture to set up an LS for the erlang test repo with the 'ignored_dir' directory ignored."""
+    ignored_paths = ["_build", "ignored_dir"]
+    ls = create_ls(ignored_paths=ignored_paths, language=Language.ERLANG)
+    ls.start()
+    try:
+        yield ls
+    finally:
+        try:
+            ls.stop(shutdown_timeout=1.0)  # Shorter timeout for CI
+        except Exception as e:
+            print(f"Warning: Error stopping language server: {e}")
+            # Force cleanup if needed
+            if hasattr(ls, "server") and hasattr(ls.server, "process"):
+                try:
+                    ls.server.process.terminate()
+                except:
+                    pass
+
+
+@pytest.mark.timeout(60)  # Add 60 second timeout
+@pytest.mark.xfail(reason="Known timeout issue on Ubuntu CI with Erlang LS server startup", strict=False)
+@pytest.mark.parametrize("ls_with_ignored_dirs", [Language.ERLANG], indirect=True)
+def test_symbol_tree_ignores_dir(ls_with_ignored_dirs: SolidLanguageServer):
+    """Tests that request_full_symbol_tree ignores the configured directory."""
+    root = ls_with_ignored_dirs.request_full_symbol_tree()[0]
+    root_children = root["children"]
+    children_names = {child["name"] for child in root_children}
+
+    # Should have src, include, and test directories, but not _build or ignored_dir
+    expected_dirs = {"src", "include", "test"}
+    found_expected = expected_dirs.intersection(children_names)
+    assert len(found_expected) > 0, f"Expected some dirs from {expected_dirs} to be in {children_names}"
+    assert "_build" not in children_names, f"_build should not be in {children_names}"
+    assert "ignored_dir" not in children_names, f"ignored_dir should not be in {children_names}"
+
+
+@pytest.mark.timeout(60)  # Add 60 second timeout
+@pytest.mark.xfail(reason="Known timeout issue on Ubuntu CI with Erlang LS server startup", strict=False)
+@pytest.mark.parametrize("ls_with_ignored_dirs", [Language.ERLANG], indirect=True)
+def test_find_references_ignores_dir(ls_with_ignored_dirs: SolidLanguageServer):
+    """Tests that find_references ignores the configured directory."""
+    # Location of user record, which might be referenced in ignored_dir
+    definition_file = "include/records.hrl"
+
+    # Find the user record definition
+    symbols = ls_with_ignored_dirs.request_document_symbols(definition_file)
+    user_symbol = None
+    for symbol_group in symbols:
+        user_symbol = next((s for s in symbol_group if "user" in s.get("name", "").lower()), None)
+        if user_symbol:
+            break
+
+    if not user_symbol or "selectionRange" not in user_symbol:
+        pytest.skip("User record symbol not found for reference testing")
+
+    sel_start = user_symbol["selectionRange"]["start"]
+    references = ls_with_ignored_dirs.request_references(definition_file, sel_start["line"], sel_start["character"])
+
+    # Assert that _build and ignored_dir do not appear in the references
+    assert not any("_build" in ref["relativePath"] for ref in references), "_build should be ignored"
+    assert not any("ignored_dir" in ref["relativePath"] for ref in references), "ignored_dir should be ignored"
+
+
+@pytest.mark.timeout(90)  # Longer timeout for this complex test
+@pytest.mark.xfail(reason="Known timeout issue on Ubuntu CI with Erlang LS server startup", strict=False)
+@pytest.mark.parametrize("repo_path", [Language.ERLANG], indirect=True)
+def test_refs_and_symbols_with_glob_patterns(repo_path: Path) -> None:
+    """Tests that refs and symbols with glob patterns are ignored."""
+    ignored_paths = ["_build*", "ignored_*", "*.tmp"]
+    ls = create_ls(ignored_paths=ignored_paths, repo_path=str(repo_path), language=Language.ERLANG)
+    ls.start()
+
+    try:
+        # Same as in the above tests
+        root = ls.request_full_symbol_tree()[0]
+        root_children = root["children"]
+        children_names = {child["name"] for child in root_children}
+
+        # Should have src, include, and test directories, but not _build or ignored_dir
+        expected_dirs = {"src", "include", "test"}
+        found_expected = expected_dirs.intersection(children_names)
+        assert len(found_expected) > 0, f"Expected some dirs from {expected_dirs} to be in {children_names}"
+        assert "_build" not in children_names, f"_build should not be in {children_names} (glob pattern)"
+        assert "ignored_dir" not in children_names, f"ignored_dir should not be in {children_names} (glob pattern)"
+
+        # Test that the refs and symbols with glob patterns are ignored
+        definition_file = "include/records.hrl"
+
+        # Find the user record definition
+        symbols = ls.request_document_symbols(definition_file)
+        user_symbol = None
+        for symbol_group in symbols:
+            user_symbol = next((s for s in symbol_group if "user" in s.get("name", "").lower()), None)
+            if user_symbol:
+                break
+
+        if user_symbol and "selectionRange" in user_symbol:
+            sel_start = user_symbol["selectionRange"]["start"]
+            references = ls.request_references(definition_file, sel_start["line"], sel_start["character"])
+
+            # Assert that _build and ignored_dir do not appear in references
+            assert not any("_build" in ref["relativePath"] for ref in references), "_build should be ignored (glob)"
+            assert not any("ignored_dir" in ref["relativePath"] for ref in references), "ignored_dir should be ignored (glob)"
+    finally:
+        try:
+            ls.stop(shutdown_timeout=1.0)  # Shorter timeout for CI
+        except Exception as e:
+            print(f"Warning: Error stopping glob pattern test LS: {e}")
+            # Force cleanup if needed
+            if hasattr(ls, "server") and hasattr(ls.server, "process"):
+                try:
+                    ls.server.process.terminate()
+                except:
+                    pass
+
+
+@pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+def test_default_ignored_directories(language_server: SolidLanguageServer):
+    """Test that default Erlang directories are ignored."""
+    # Test that Erlang-specific directories are ignored by default
+    assert language_server.is_ignored_dirname("_build"), "_build should be ignored"
+    assert language_server.is_ignored_dirname("ebin"), "ebin should be ignored"
+    assert language_server.is_ignored_dirname("deps"), "deps should be ignored"
+    assert language_server.is_ignored_dirname(".rebar3"), ".rebar3 should be ignored"
+    assert language_server.is_ignored_dirname("_checkouts"), "_checkouts should be ignored"
+    assert language_server.is_ignored_dirname("node_modules"), "node_modules should be ignored"
+
+    # Test that important directories are not ignored
+    assert not language_server.is_ignored_dirname("src"), "src should not be ignored"
+    assert not language_server.is_ignored_dirname("include"), "include should not be ignored"
+    assert not language_server.is_ignored_dirname("test"), "test should not be ignored"
+    assert not language_server.is_ignored_dirname("priv"), "priv should not be ignored"
+
+
+@pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+def test_symbol_tree_excludes_build_dirs(language_server: SolidLanguageServer):
+    """Test that symbol tree excludes build and dependency directories."""
+    symbol_tree = language_server.request_full_symbol_tree()
+
+    if symbol_tree:
+        root = symbol_tree[0]
+        children_names = {child["name"] for child in root.get("children", [])}
+
+        # Build and dependency directories should not appear
+        ignored_dirs = {"_build", "ebin", "deps", ".rebar3", "_checkouts", "node_modules"}
+        found_ignored = ignored_dirs.intersection(children_names)
+        assert len(found_ignored) == 0, f"Found ignored directories in symbol tree: {found_ignored}"
+
+        # Important directories should appear
+        important_dirs = {"src", "include", "test"}
+        found_important = important_dirs.intersection(children_names)
+        assert len(found_important) > 0, f"Expected to find important directories: {important_dirs}, got: {children_names}"
+
+
+@pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+def test_ignore_compiled_files(language_server: SolidLanguageServer):
+    """Test that compiled Erlang files are ignored."""
+    # Test that beam files are ignored
+    assert language_server.is_ignored_filename("module.beam"), "BEAM files should be ignored"
+    assert language_server.is_ignored_filename("app.beam"), "BEAM files should be ignored"
+
+    # Test that source files are not ignored
+    assert not language_server.is_ignored_filename("module.erl"), "Erlang source files should not be ignored"
+    assert not language_server.is_ignored_filename("records.hrl"), "Header files should not be ignored"
+
+
+@pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+def test_rebar_directories_ignored(language_server: SolidLanguageServer):
+    """Test that rebar-specific directories are ignored."""
+    # Test rebar3-specific directories
+    assert language_server.is_ignored_dirname("_build"), "rebar3 _build should be ignored"
+    assert language_server.is_ignored_dirname("_checkouts"), "rebar3 _checkouts should be ignored"
+    assert language_server.is_ignored_dirname(".rebar3"), "rebar3 cache should be ignored"
+
+    # Test that rebar.lock and rebar.config are not ignored (they are configuration files)
+    assert not language_server.is_ignored_filename("rebar.config"), "rebar.config should not be ignored"
+    assert not language_server.is_ignored_filename("rebar.lock"), "rebar.lock should not be ignored"
+
+
+@pytest.mark.parametrize("ls_with_ignored_dirs", [Language.ERLANG], indirect=True)
+def test_document_symbols_ignores_dirs(ls_with_ignored_dirs: SolidLanguageServer):
+    """Test that document symbols from ignored directories are not included."""
+    # Try to get symbols from a file in ignored directory (should not find it)
+    try:
+        ignored_file = "ignored_dir/ignored_module.erl"
+        symbols = ls_with_ignored_dirs.request_document_symbols(ignored_file)
+        # If we get here, the file was found - symbols should be empty or None
+        if symbols:
+            assert len(symbols) == 0, "Should not find symbols in ignored directory"
+    except Exception:
+        # This is expected - the file should not be accessible
+        pass
+
+
+@pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+def test_erlang_specific_ignore_patterns(language_server: SolidLanguageServer):
+    """Test Erlang-specific ignore patterns work correctly."""
+    erlang_ignored_dirs = ["_build", "ebin", ".rebar3", "_checkouts", "cover"]
+
+    # These should be ignored
+    for dirname in erlang_ignored_dirs:
+        assert language_server.is_ignored_dirname(dirname), f"{dirname} should be ignored"
+
+    # These should not be ignored
+    erlang_important_dirs = ["src", "include", "test", "priv"]
+    for dirname in erlang_important_dirs:
+        assert not language_server.is_ignored_dirname(dirname), f"{dirname} should not be ignored"