java-functional-lsp 0.9.13__tar.gz → 0.9.15__tar.gz

java_functional_lsp-0.9.15/.claude-plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "java-functional-lsp",
+  "description": "Java LSP with functional programming rules enforcement — null safety, immutability, no exceptions, Spring best practices. Wraps jdtls for full Java language support.",
+  "version": "0.4.2",
+  "lspServers": {
+    "java-functional": {
+      "command": "java-functional-lsp",
+      "extensionToLanguage": {
+        ".java": "java"
+      },
+      "startupTimeout": 120000,
+      "restartOnCrash": true,
+      "maxRestarts": 5
+    }
+  }
+}

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.13
+Version: 0.9.15
 Summary: Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions
 Project-URL: Homepage, https://github.com/aviadshiber/java-functional-lsp
 Project-URL: Repository, https://github.com/aviadshiber/java-functional-lsp
@@ -136,11 +136,17 @@ See [editors/intellij/README.md](editors/intellij/README.md) for detailed instru
 
 **Step 1: Enable LSP support** (required, one-time):
 
-Add to `~/.claude/settings.json`:
+Add `lspServers` to `~/.claude/settings.json` (the plugin handles this automatically — only needed for manual setup):
 ```json
 {
-  "env": {
-    "ENABLE_LSP_TOOL": "1"
+  "lspServers": {
+    "java-functional": {
+      "command": "java-functional-lsp",
+      "extensionToLanguage": { ".java": "java" },
+      "startupTimeout": 120000,
+      "restartOnCrash": true,
+      "maxRestarts": 5
+    }
   }
 }
 ```
@@ -160,19 +166,27 @@ Or manually add to your Claude Code config:
   "lspServers": {
     "java-functional": {
       "command": "java-functional-lsp",
-      "extensionToLanguage": { ".java": "java" }
+      "extensionToLanguage": { ".java": "java" },
+      "startupTimeout": 120000,
+      "restartOnCrash": true,
+      "maxRestarts": 5
     }
   }
 }
 ```
 
+(`startupTimeout: 120000` accommodates jdtls cold-start; `restartOnCrash` keeps the server alive across session.)
+
 **Alternative: project-level `.lsp.json`** — instead of installing the plugin or editing global config, add a `.lsp.json` file at your project root:
 
 ```json
 {
   "java-functional": {
     "command": "java-functional-lsp",
-    "extensionToLanguage": { ".java": "java" }
+    "extensionToLanguage": { ".java": "java" },
+    "startupTimeout": 120000,
+    "restartOnCrash": true,
+    "maxRestarts": 5
   }
 }
 ```
@@ -198,7 +212,7 @@ moving on. Fix any type errors or missing imports immediately.
 
 | Issue | Fix |
 |-------|-----|
-| No diagnostics appear | Ensure `ENABLE_LSP_TOOL=1` is set, restart Claude Code |
+| No diagnostics appear | Ensure `lspServers` is configured (plugin or settings.json), restart |
 | "java-functional-lsp not found" | Run `brew install aviadshiber/tap/java-functional-lsp` |
 | Plugin not active | Run `claude plugin list` to verify, then `/reload-plugins` |
 | Diagnostics slow on first open | Normal — tree-sitter parses on first load, then incremental |

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/README.md

@@ -108,11 +108,17 @@ See [editors/intellij/README.md](editors/intellij/README.md) for detailed instru
 
 **Step 1: Enable LSP support** (required, one-time):
 
-Add to `~/.claude/settings.json`:
+Add `lspServers` to `~/.claude/settings.json` (the plugin handles this automatically — only needed for manual setup):
 ```json
 {
-  "env": {
-    "ENABLE_LSP_TOOL": "1"
+  "lspServers": {
+    "java-functional": {
+      "command": "java-functional-lsp",
+      "extensionToLanguage": { ".java": "java" },
+      "startupTimeout": 120000,
+      "restartOnCrash": true,
+      "maxRestarts": 5
+    }
   }
 }
 ```
@@ -132,19 +138,27 @@ Or manually add to your Claude Code config:
   "lspServers": {
     "java-functional": {
       "command": "java-functional-lsp",
-      "extensionToLanguage": { ".java": "java" }
+      "extensionToLanguage": { ".java": "java" },
+      "startupTimeout": 120000,
+      "restartOnCrash": true,
+      "maxRestarts": 5
     }
   }
 }
 ```
 
+(`startupTimeout: 120000` accommodates jdtls cold-start; `restartOnCrash` keeps the server alive across session.)
+
 **Alternative: project-level `.lsp.json`** — instead of installing the plugin or editing global config, add a `.lsp.json` file at your project root:
 
 ```json
 {
   "java-functional": {
     "command": "java-functional-lsp",
-    "extensionToLanguage": { ".java": "java" }
+    "extensionToLanguage": { ".java": "java" },
+    "startupTimeout": 120000,
+    "restartOnCrash": true,
+    "maxRestarts": 5
   }
 }
 ```
@@ -170,7 +184,7 @@ moving on. Fix any type errors or missing imports immediately.
 
 | Issue | Fix |
 |-------|-----|
-| No diagnostics appear | Ensure `ENABLE_LSP_TOOL=1` is set, restart Claude Code |
+| No diagnostics appear | Ensure `lspServers` is configured (plugin or settings.json), restart |
 | "java-functional-lsp not found" | Run `brew install aviadshiber/tap/java-functional-lsp` |
 | Plugin not active | Run `claude plugin list` to verify, then `/reload-plugins` |
 | Diagnostics slow on first open | Normal — tree-sitter parses on first load, then incremental |

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/SKILL.md

@@ -112,14 +112,11 @@ To release a new version:
 
 ## Enabling LSP in Claude Code
 
-LSP support requires `ENABLE_LSP_TOOL=1` in `~/.claude/settings.json`:
-```json
-{ "env": { "ENABLE_LSP_TOOL": "1" } }
-```
+Declare `lspServers` in `~/.claude/settings.json` or in `plugin.json` — Claude Code enables the LSP tool automatically when `lspServers` is configured. `ENABLE_LSP_TOOL=1` is no longer needed.
 
 For containers or CI, add a `.lsp.json` at the project root instead of installing the plugin:
 ```json
-{ "java-functional": { "command": "java-functional-lsp", "extensionToLanguage": { ".java": "java" } } }
+{ "java-functional": { "command": "java-functional-lsp", "extensionToLanguage": { ".java": "java" }, "startupTimeout": 120000, "restartOnCrash": true, "maxRestarts": 5 } }
 ```
 
 To nudge Claude to act on diagnostics, add to your project's `CLAUDE.md`:
@@ -130,7 +127,7 @@ Fix any violations immediately — do not explain, just apply the fix.
 
 ## Troubleshooting
 
-- **No diagnostics in Claude Code**: Ensure `ENABLE_LSP_TOOL=1` is set, restart Claude Code
+- **No diagnostics in Claude Code**: Ensure `lspServers` is configured (in `plugin.json` or `settings.json`), restart Claude Code
 - **"java-functional-lsp not found"**: Run `brew install aviadshiber/tap/java-functional-lsp`
 - **No completions/hover**: Install jdtls: `brew install jdtls` (requires JDK 21+)
 - **Too many warnings**: Create `.java-functional-lsp.json` with `excludes` or per-rule severity

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.13"
+version = "0.9.15"
 description = "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions"
 readme = "README.md"
 license = { text = "MIT" }

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/src/java_functional_lsp/__init__.py

@@ -1,3 +1,3 @@
 """java-functional-lsp: A Java LSP server enforcing functional programming best practices."""
 
-__version__ = "0.9.13"
+__version__ = "0.9.14"

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/src/java_functional_lsp/proxy.py

@@ -29,6 +29,7 @@ _START_RETRY_COOLDOWN = 300.0  # seconds — retry jdtls startup after transient
 DEFAULT_JVM_MAX_HEAP = "4g"
 _STDERR_LINE_MAX = 1000
 _MAX_EXPANDED_GROUPS: int = 5  # hard cap on concurrent Maven group workspace folders (prevents jdtls OOM)
+_WORKSPACE_CACHE_MAX_SIZE: int = 10  # default LRU cap — override via {"cache": {"maxWorkspaces": N}}
 
 # Default jdtls initialization settings.  Sent via initializationOptions.settings
 # so they apply BEFORE the Maven import scan (didChangeConfiguration is too late).
@@ -563,6 +564,87 @@ def _compute_module_diff(
     return (diff, current)
 
 
+def _dir_mtime(path: Path) -> float:
+    """Return ``st_mtime`` of *path*, or ``float('inf')`` on any OSError.
+
+    Returning infinity on error sorts the directory as the *newest* entry,
+    so stat-inaccessible directories are conservatively kept rather than
+    silently evicted.
+    """
+    try:
+        return path.stat().st_mtime
+    except OSError:
+        return float("inf")
+
+
+def _parse_max_workspaces(config: Mapping[str, Any] | None) -> int:
+    """Parse and validate ``cache.maxWorkspaces`` from the project config.
+
+    Returns *_WORKSPACE_CACHE_MAX_SIZE* when the key is absent, when the value
+    cannot be converted to ``int``, or when the result is not positive.  Logs a
+    warning in each error case so the user can diagnose the misconfiguration.
+    """
+    raw = (config or {}).get("cache", {}).get("maxWorkspaces")
+    if raw is None:
+        return _WORKSPACE_CACHE_MAX_SIZE
+    try:
+        value = int(raw)
+    except (TypeError, ValueError):
+        logger.warning(
+            "jdtls: invalid cache.maxWorkspaces %r — using default %d",
+            raw,
+            _WORKSPACE_CACHE_MAX_SIZE,
+        )
+        return _WORKSPACE_CACHE_MAX_SIZE
+    if value <= 0:
+        logger.warning(
+            "jdtls: cache.maxWorkspaces must be >= 1, got %d — using default %d",
+            value,
+            _WORKSPACE_CACHE_MAX_SIZE,
+        )
+        return _WORKSPACE_CACHE_MAX_SIZE
+    return value
+
+
+def _evict_lru_workspaces(cache_root: Path, *, max_size: int = _WORKSPACE_CACHE_MAX_SIZE) -> None:
+    """Evict least-recently-used jdtls workspace directories when count exceeds *max_size*.
+
+    Implements Caffeine's ``maximumSize`` eviction policy for a filesystem cache.
+    Directories are ordered by ``st_mtime`` (last modification time), which is a
+    reliable proxy for last-used time because jdtls always writes to its workspace
+    on startup.  On macOS APFS (``noatime`` default) ``atime`` is not updated on
+    reads, so ``mtime`` is used exclusively.
+
+    The *max_size* most-recently-modified real directories are kept; the rest are
+    removed.  Dotfiles (e.g. ``.version``), symlinks, and non-directory entries
+    are excluded from the eviction candidates.
+
+    A directory whose ``stat()`` raises ``OSError`` is treated as the *newest*
+    entry (``float('inf')`` mtime) so it is conservatively kept.
+
+    Runs in the executor thread (``_blocking_startup``) — never blocks the event loop.
+
+    Users can tune the cap via ``.java-functional-lsp.json``:
+    ``{"cache": {"maxWorkspaces": 20}}``
+    """
+    if not cache_root.is_dir():
+        return
+    try:
+        dirs = [d for d in cache_root.iterdir() if d.is_dir() and not d.is_symlink() and not d.name.startswith(".")]
+    except OSError as e:
+        logger.warning("jdtls: cannot scan cache root for eviction: %s", e)
+        return
+    if len(dirs) <= max_size:
+        return
+    dirs.sort(key=_dir_mtime, reverse=True)  # newest first
+    for stale in dirs[max_size:]:
+        try:
+            shutil.rmtree(stale)
+            logger.info("jdtls: evicted workspace cache %s (LRU)", stale.name)
+        except OSError as e:
+            logger.warning("jdtls: failed to evict workspace cache %s: %s", stale.name, e)
+
+
 def _wipe_data_dir(data_dir: Path) -> None:
     """Remove *data_dir* so the next jdtls startup gets a clean cold start.
 
@@ -793,6 +875,8 @@ class JdtlsProxy:
 
         def _blocking_startup() -> tuple[dict[str, str], str | None]:
             _clear_cache_on_version_change(cache_root)
+            max_workspaces = _parse_max_workspaces(config)
+            _evict_lru_workspaces(cache_root, max_size=max_workspaces)
             return build_jdtls_env(), _find_lombok_jar(config)
 
         loop = asyncio.get_running_loop()

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/src/java_functional_lsp/server.py

@@ -369,6 +369,24 @@ def _jdtls_raw_to_lsp_diagnostics(raw_diagnostics: list[Any]) -> list[lsp.Diagno
 
 _MAX_PATTERN_LENGTH = 500  # Cap regex length to mitigate ReDoS from pathological patterns
 
+_M2E_SOURCES: frozenset[str] = frozenset({"org.eclipse.m2e"})
+_M2E_MESSAGE_PATTERNS: re.Pattern[str] = re.compile(
+    r"Plugin execution not covered by lifecycle configuration"
+    r"|The project cannot be built until its prerequisite"
+    r"|Failed to execute mojo"
+)
+
+
+def _is_m2e_marker(diag: dict[str, Any]) -> bool:
+    """Return True if the diagnostic is an Eclipse/M2E lifecycle marker (not a Java error)."""
+    if str(diag.get("code", "")) == "0":
+        return True
+    if diag.get("source", "") in _M2E_SOURCES:
+        return True
+    if _M2E_MESSAGE_PATTERNS.search(diag.get("message", "")):
+        return True
+    return False
+
 
 def _compile_user_patterns(config: dict[str, Any]) -> list[re.Pattern[str]]:
     """Compile user-defined suppressJdtlsPatterns from config."""
@@ -417,7 +435,9 @@ def _run_analysis(source: str, uri: str) -> list[lsp.Diagnostic]:
     if server._proxy.is_available:
         try:
             raw = server._proxy.get_cached_diagnostics(uri)
-            raw = [d for d in raw if not _is_jdtls_suppressed(d, server._user_suppress_patterns)]
+            raw = [
+                d for d in raw if not _is_m2e_marker(d) and not _is_jdtls_suppressed(d, server._user_suppress_patterns)
+            ]
             jdtls_diags = _jdtls_raw_to_lsp_diagnostics(raw)
         except Exception as e:
             logger.warning("jdtls diagnostic processing failed for %s: %s", uri, e)

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/tests/test_e2e_jdtls.py

@@ -68,6 +68,10 @@ pytestmark = [
 # so a hung jdtls doesn't wedge the suite.
 _E2E_TEST_TIMEOUT_SEC = 120
 _JDTLS_PARSE_WAIT_SEC = 2.5
+# Max wall-clock seconds to poll for a non-empty documentSymbol result.
+# macOS CI runners are slower than Linux; 60s accommodates cold-start variance.
+_JDTLS_SYMBOL_POLL_TIMEOUT_SEC = 60
+_JDTLS_SYMBOL_POLL_INTERVAL_SEC = 1.0
 
 _HELLO_JAVA = """\
 public class Hello {
@@ -260,7 +264,16 @@ class TestJdtlsEndToEnd:
             assert "textDocument" in serialized, f"_serialize_params emitted wrong field names: {serialized.keys()}"
             assert "text_document" not in serialized
 
-            result = await proxy.send_request("textDocument/documentSymbol", serialized)
+            # Poll until jdtls returns a non-empty symbol list or we time out.
+            # A fixed sleep is unreliable on macOS CI where jdtls cold-start
+            # can reach 20s; polling adapts to the actual indexing speed.
+            deadline = asyncio.get_event_loop().time() + _JDTLS_SYMBOL_POLL_TIMEOUT_SEC
+            result = None
+            while asyncio.get_event_loop().time() < deadline:
+                result = await proxy.send_request("textDocument/documentSymbol", serialized)
+                if result:
+                    break
+                await asyncio.sleep(_JDTLS_SYMBOL_POLL_INTERVAL_SEC)
 
         # Primary assertion: jdtls returned something. With a correctly-shaped
         # request, jdtls always returns a list (possibly empty) for a parsable
@@ -274,7 +287,8 @@ class TestJdtlsEndToEnd:
         assert isinstance(result, list)
         # Hello.java declares a top-level class, so we expect at least one symbol.
         assert len(result) > 0, (
-            "jdtls returned an empty symbol list for a file with a top-level class. "
+            "jdtls returned an empty symbol list for a file with a top-level class "
+            f"after polling for {_JDTLS_SYMBOL_POLL_TIMEOUT_SEC}s. "
             "Either jdtls didn't finish parsing or the file wasn't opened correctly."
         )
 

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/tests/test_proxy.py

@@ -4,7 +4,10 @@ from __future__ import annotations
 
 import asyncio
 import json
+import os
+import shutil
 import subprocess
+import time
 from pathlib import Path
 from typing import Any
 from unittest.mock import MagicMock, patch
@@ -1517,3 +1520,235 @@ class TestWipeDataDir:
         from java_functional_lsp.proxy import _wipe_data_dir
 
         _wipe_data_dir(tmp_path / "ghost")  # should not raise
+
+
+class TestEvictLruWorkspaces:
+    """Tests for _evict_lru_workspaces — count-based LRU eviction of jdtls workspace dirs."""
+
+    @staticmethod
+    def _make_workspace(cache_root: Path, name: str, mtime_age_days: float) -> Path:
+        """Create a fake workspace dir and backdate its mtime."""
+        d = cache_root / name
+        d.mkdir()
+        ts = time.time() - mtime_age_days * 86400.0
+        os.utime(d, (ts, ts))
+        return d
+
+    def test_noop_on_missing_cache_root(self, tmp_path: Path) -> None:
+        """No error when cache_root does not exist."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        _evict_lru_workspaces(tmp_path / "nonexistent", max_size=10)
+        # No exception raised — that is the assertion
+
+    def test_noop_when_at_or_below_max_size(self, tmp_path: Path) -> None:
+        """No eviction when count <= max_size."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        d1 = self._make_workspace(tmp_path, "aabbccdd1234", mtime_age_days=5)
+        d2 = self._make_workspace(tmp_path, "1122334455ab", mtime_age_days=3)
+        _evict_lru_workspaces(tmp_path, max_size=2)
+        assert d1.exists()
+        assert d2.exists()
+
+    def test_evicts_oldest_when_over_max_size(self, tmp_path: Path) -> None:
+        """Oldest dirs (lowest mtime) are removed; newest are kept."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        oldest = self._make_workspace(tmp_path, "aabbccdd1111", mtime_age_days=10)
+        middle = self._make_workspace(tmp_path, "aabbccdd2222", mtime_age_days=5)
+        newest = self._make_workspace(tmp_path, "aabbccdd3333", mtime_age_days=1)
+        _evict_lru_workspaces(tmp_path, max_size=2)
+        assert not oldest.exists()
+        assert middle.exists()
+        assert newest.exists()
+
+    def test_dotfiles_never_evicted(self, tmp_path: Path) -> None:
+        """.version and other dotfiles are excluded from eviction."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        marker = tmp_path / ".version"
+        marker.write_text("abc|21")
+        old_ts = time.time() - 999 * 86400.0
+        os.utime(marker, (old_ts, old_ts))
+        # max_size=0 would evict everything — dotfiles must still survive
+        _evict_lru_workspaces(tmp_path, max_size=0)
+        assert marker.exists()
+
+    def test_dotdirs_never_evicted(self, tmp_path: Path) -> None:
+        """Dotfile directories (e.g. .hidden/) are excluded from eviction."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        hidden_dir = tmp_path / ".hidden"
+        hidden_dir.mkdir()
+        old_ts = time.time() - 999 * 86400.0
+        os.utime(hidden_dir, (old_ts, old_ts))
+        _evict_lru_workspaces(tmp_path, max_size=0)
+        assert hidden_dir.exists()
+
+    def test_non_directory_entries_ignored(self, tmp_path: Path) -> None:
+        """Plain files in cache_root are never removed."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        stray = tmp_path / "stray.txt"
+        stray.write_text("irrelevant")
+        old_ts = time.time() - 999 * 86400.0
+        os.utime(stray, (old_ts, old_ts))
+        _evict_lru_workspaces(tmp_path, max_size=0)
+        assert stray.exists()
+
+    def test_symlinks_never_evicted(self, tmp_path: Path) -> None:
+        """Symlinks in cache_root are excluded — shutil.rmtree must not follow them."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        # Target is a dotdir (excluded from candidates) so it is never evicted.
+        # This prevents the symlink from going dangling during the test.
+        target = tmp_path / ".hidden_target"
+        target.mkdir()
+        link = tmp_path / "aabbccdd1111"
+        link.symlink_to(target)
+        old_ts = time.time() - 999 * 86400.0
+        os.utime(link, (old_ts, old_ts))
+        _evict_lru_workspaces(tmp_path, max_size=0)
+        assert link.exists()  # symlink itself must survive
+        assert target.exists()  # target must not be deleted
+
+    def test_dir_mtime_returns_inf_on_oserror(self, tmp_path: Path) -> None:
+        """_dir_mtime returns float('inf') when stat() fails — non-zero sentinel."""
+        from java_functional_lsp.proxy import _dir_mtime
+
+        assert _dir_mtime(tmp_path / "nonexistent") == float("inf")
+
+    def test_stat_error_conservatively_keeps_dir(self, tmp_path: Path) -> None:
+        """Dir whose _dir_mtime returns inf is sorted as newest — conservatively kept.
+
+        Patching _dir_mtime directly (not Path.stat) avoids interfering with
+        is_dir() which also calls stat() internally.
+        """
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        older = self._make_workspace(tmp_path, "aabbccdd1111", mtime_age_days=10)
+        kept_dir = self._make_workspace(tmp_path, "aabbccdd2222", mtime_age_days=5)
+
+        original_dir_mtime = proxy_mod._dir_mtime
+
+        def patched_dir_mtime(path: Path) -> float:
+            if path.name == kept_dir.name:
+                return float("inf")
+            return original_dir_mtime(path)
+
+        with patch("java_functional_lsp.proxy._dir_mtime", patched_dir_mtime):
+            # kept_dir: _dir_mtime returns inf → sorted as newest → kept
+            # older: mtime=10 days ago → sorted as oldest → evicted
+            _evict_lru_workspaces(tmp_path, max_size=1)
+
+        assert kept_dir.exists()  # conservatively kept (inf mtime)
+        assert not older.exists()  # evicted as the oldest accessible dir
+
+    def test_rmtree_error_logged_and_continued(self, tmp_path: Path) -> None:
+        """OSError on rmtree emits a warning and continues evicting remaining dirs."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        d1 = self._make_workspace(tmp_path, "aabbccdd1111", mtime_age_days=10)
+        self._make_workspace(tmp_path, "aabbccdd2222", mtime_age_days=5)
+        d3 = self._make_workspace(tmp_path, "aabbccdd3333", mtime_age_days=1)
+
+        call_count = 0
+        original_rmtree = shutil.rmtree
+
+        def patched_rmtree(path: Any, **kw: Any) -> None:
+            nonlocal call_count
+            call_count += 1
+            if Path(path).name == d1.name:
+                raise OSError("busy")
+            original_rmtree(path, **kw)
+
+        with patch("java_functional_lsp.proxy.shutil.rmtree", side_effect=patched_rmtree):
+            with patch("java_functional_lsp.proxy.logger") as mock_logger:
+                _evict_lru_workspaces(tmp_path, max_size=1)
+                # Warning for d1 (rmtree failed); info for d2 (evicted successfully)
+                assert mock_logger.warning.call_count >= 1
+                assert mock_logger.info.call_count >= 1
+
+        assert d3.exists()  # newest kept
+
+    def test_logs_info_on_eviction(self, tmp_path: Path) -> None:
+        """Info log is emitted for each evicted workspace dir, including 'LRU'."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        self._make_workspace(tmp_path, "aabbccdd1111", mtime_age_days=10)
+        self._make_workspace(tmp_path, "aabbccdd2222", mtime_age_days=1)
+
+        with patch("java_functional_lsp.proxy.logger") as mock_logger:
+            _evict_lru_workspaces(tmp_path, max_size=1)
+
+        info_calls = [str(c) for c in mock_logger.info.call_args_list]
+        assert any("aabbccdd1111" in m and "LRU" in m for m in info_calls)
+
+    def test_max_size_param_respected(self, tmp_path: Path) -> None:
+        """Passing max_size=3 keeps exactly 3 dirs (the 3 newest)."""
+        from java_functional_lsp.proxy import _evict_lru_workspaces
+
+        dirs = [self._make_workspace(tmp_path, f"workspace{i:04d}", mtime_age_days=float(10 - i)) for i in range(6)]
+        _evict_lru_workspaces(tmp_path, max_size=3)
+        surviving = [d for d in dirs if d.exists()]
+        assert len(surviving) == 3
+        # The 3 newest (smallest age = largest mtime) must survive
+        for d in dirs[-3:]:
+            assert d.exists()
+
+
+class TestParseMaxWorkspaces:
+    """Tests for _parse_max_workspaces — config validation for the LRU cap."""
+
+    def test_none_config_returns_default(self) -> None:
+        from java_functional_lsp.proxy import _WORKSPACE_CACHE_MAX_SIZE, _parse_max_workspaces
+
+        assert _parse_max_workspaces(None) == _WORKSPACE_CACHE_MAX_SIZE
+
+    def test_empty_config_returns_default(self) -> None:
+        from java_functional_lsp.proxy import _WORKSPACE_CACHE_MAX_SIZE, _parse_max_workspaces
+
+        assert _parse_max_workspaces({}) == _WORKSPACE_CACHE_MAX_SIZE
+
+    def test_missing_cache_key_returns_default(self) -> None:
+        from java_functional_lsp.proxy import _WORKSPACE_CACHE_MAX_SIZE, _parse_max_workspaces
+
+        assert _parse_max_workspaces({"jdtls": {}}) == _WORKSPACE_CACHE_MAX_SIZE
+
+    def test_valid_value_is_returned(self) -> None:
+        from java_functional_lsp.proxy import _parse_max_workspaces
+
+        assert _parse_max_workspaces({"cache": {"maxWorkspaces": 5}}) == 5
+        assert _parse_max_workspaces({"cache": {"maxWorkspaces": 1}}) == 1
+        assert _parse_max_workspaces({"cache": {"maxWorkspaces": 100}}) == 100
+
+    def test_string_integer_is_accepted(self) -> None:
+        """A string that represents a valid integer (e.g. from JSON) is parsed."""
+        from java_functional_lsp.proxy import _parse_max_workspaces
+
+        assert _parse_max_workspaces({"cache": {"maxWorkspaces": "7"}}) == 7
+
+    def test_invalid_string_returns_default_with_warning(self) -> None:
+        from java_functional_lsp.proxy import _WORKSPACE_CACHE_MAX_SIZE, _parse_max_workspaces
+
+        with patch("java_functional_lsp.proxy.logger") as mock_logger:
+            result = _parse_max_workspaces({"cache": {"maxWorkspaces": "bad"}})
+        assert result == _WORKSPACE_CACHE_MAX_SIZE
+        mock_logger.warning.assert_called_once()
+
+    def test_zero_returns_default_with_warning(self) -> None:
+        from java_functional_lsp.proxy import _WORKSPACE_CACHE_MAX_SIZE, _parse_max_workspaces
+
+        with patch("java_functional_lsp.proxy.logger") as mock_logger:
+            result = _parse_max_workspaces({"cache": {"maxWorkspaces": 0}})
+        assert result == _WORKSPACE_CACHE_MAX_SIZE
+        mock_logger.warning.assert_called_once()
+
+    def test_negative_returns_default_with_warning(self) -> None:
+        from java_functional_lsp.proxy import _WORKSPACE_CACHE_MAX_SIZE, _parse_max_workspaces
+
+        with patch("java_functional_lsp.proxy.logger") as mock_logger:
+            result = _parse_max_workspaces({"cache": {"maxWorkspaces": -1}})
+        assert result == _WORKSPACE_CACHE_MAX_SIZE
+        mock_logger.warning.assert_called_once()

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/tests/test_server.py

@@ -71,10 +71,15 @@ async def lsp_client(tmp_path: Any) -> LanguageClient:  # type: ignore[misc]
 
     # Collect published diagnostics so tests can assert on them.
     client._published: dict[str, list[lsp.Diagnostic]] = {}  # type: ignore[attr-defined]
+    # Per-URI events signalled by on_publish — used by _open_and_wait_for_diagnostics.
+    client._diag_events: dict[str, asyncio.Event] = {}  # type: ignore[attr-defined]
 
     @client.feature(lsp.TEXT_DOCUMENT_PUBLISH_DIAGNOSTICS)
     def on_publish(params: lsp.PublishDiagnosticsParams) -> None:
         client._published[params.uri] = list(params.diagnostics)  # type: ignore[attr-defined]
+        evt = client._diag_events.get(params.uri)  # type: ignore[attr-defined]
+        if evt is not None:
+            evt.set()
 
     await client.start_io(sys.executable, "-m", "java_functional_lsp")
 
@@ -121,10 +126,21 @@ async def _open_and_wait_for_diagnostics(
 ) -> list[lsp.Diagnostic]:
     """Open a document and wait until publishDiagnostics arrives for its URI.
 
-    The server publishes diagnostics asynchronously after didOpen. We poll
-    the client's collected notifications until the URI appears or timeout.
+    The server publishes diagnostics asynchronously after didOpen. We register
+    an asyncio.Event that on_publish signals, then await it with wait_for so the
+    full timeout is always respected — even when the event loop is transiently
+    busy (e.g. jdtls subprocess creation on a slow macOS runner).
+
+    Note: the server always emits publishDiagnostics for every opened file
+    (including clean ones with zero findings) synchronously inside on_did_open,
+    before jdtls is involved. The event is therefore guaranteed to fire on the
+    first — and correct — notification for each URI in this test setup.
     """
     client._published.pop(uri, None)  # type: ignore[attr-defined]
+    # Register event before sending didOpen — no await between these two lines,
+    # so on_publish cannot fire and miss the registration.
+    event = asyncio.Event()
+    client._diag_events[uri] = event  # type: ignore[attr-defined]
 
     client.text_document_did_open(
         lsp.DidOpenTextDocumentParams(
@@ -137,14 +153,18 @@ async def _open_and_wait_for_diagnostics(
         )
     )
 
-    deadline = asyncio.get_running_loop().time() + timeout
-    while asyncio.get_running_loop().time() < deadline:
-        if uri in client._published:  # type: ignore[attr-defined]
-            return client._published[uri]  # type: ignore[attr-defined]
-        await asyncio.sleep(0.1)
+    try:
+        await asyncio.wait_for(event.wait(), timeout=timeout)
+    except asyncio.TimeoutError:
+        # pytest.fail() raises Failed (a BaseException subclass);
+        # the finally block below still runs before the exception propagates.
+        pytest.fail(f"Timed out waiting for publishDiagnostics on {uri}")
+    finally:
+        client._diag_events.pop(uri, None)  # type: ignore[attr-defined]
 
-    pytest.fail(f"Timed out waiting for publishDiagnostics on {uri}")
-    return []  # unreachable, but satisfies type checker
+    # on_publish stores to _published before setting the event, so the key
+    # is guaranteed to exist here — use direct access to surface any violation.
+    return client._published[uri]  # type: ignore[attr-defined]
 
 
 # --------------------------------------------------------------------------
@@ -2077,7 +2097,7 @@ class TestCacheClear:
 # --------------------------------------------------------------------------
 
 
-@pytest.mark.timeout(30)
+@pytest.mark.timeout(60)  # covers fixture setup (subprocess spawn + initialize handshake) on slow macOS runners
 class TestLspLifecycle:
     """Full LSP lifecycle tests via real stdio transport — zero mocks."""
 
@@ -2234,3 +2254,90 @@ class TestLspLifecycle:
         assert uri in lsp_client._published, "Timed out waiting for updated diagnostics after didChange"  # type: ignore[attr-defined]
         new_diags = lsp_client._published[uri]  # type: ignore[attr-defined]
         assert len(new_diags) == 0, f"Expected zero diagnostics after fixing, got {[d.code for d in new_diags]}"
+
+
+class TestM2EMarkerFilter:
+    """Tests for built-in suppression of Eclipse/M2E lifecycle markers."""
+
+    def test_code_zero_string_is_suppressed(self) -> None:
+        from java_functional_lsp.server import _is_m2e_marker
+
+        assert _is_m2e_marker({"code": "0", "message": "some message"}) is True
+
+    def test_code_zero_int_is_suppressed(self) -> None:
+        from java_functional_lsp.server import _is_m2e_marker
+
+        assert _is_m2e_marker({"code": 0, "message": "some message"}) is True
+
+    def test_m2e_source_is_suppressed(self) -> None:
+        from java_functional_lsp.server import _is_m2e_marker
+
+        assert _is_m2e_marker({"code": "100", "source": "org.eclipse.m2e", "message": "anything"}) is True
+
+    def test_plugin_execution_message_is_suppressed(self) -> None:
+        from java_functional_lsp.server import _is_m2e_marker
+
+        diag = {"message": "Plugin execution not covered by lifecycle configuration: maven-antrun-plugin:3.1.0:run"}
+        assert _is_m2e_marker(diag) is True
+
+    def test_prerequisite_message_is_suppressed(self) -> None:
+        from java_functional_lsp.server import _is_m2e_marker
+
+        diag = {"message": "The project cannot be built until its prerequisite com.example-core is built."}
+        assert _is_m2e_marker(diag) is True
+
+    def test_failed_mojo_message_is_suppressed(self) -> None:
+        from java_functional_lsp.server import _is_m2e_marker
+
+        diag = {"message": "Failed to execute mojo org.apache.maven.plugins:maven-dependency-plugin:3.6.0"}
+        assert _is_m2e_marker(diag) is True
+
+    def test_non_project_code_16_is_not_suppressed(self) -> None:
+        """Code 16 (jdtls non-project) must not be caught by the M2E filter."""
+        from java_functional_lsp.server import _is_m2e_marker
+
+        diag = {"code": "16", "source": "jdtls", "message": "File not on the classpath"}
+        assert _is_m2e_marker(diag) is False
+
+    def test_real_java_error_is_not_suppressed(self) -> None:
+        from java_functional_lsp.server import _is_m2e_marker
+
+        diag = {"code": "100", "source": "jdtls", "message": "The method foo() is undefined for the type Bar"}
+        assert _is_m2e_marker(diag) is False
+
+    def test_missing_fields_do_not_raise(self) -> None:
+        from java_functional_lsp.server import _is_m2e_marker
+
+        assert _is_m2e_marker({}) is False
+
+    def test_m2e_marker_excluded_from_run_analysis(self) -> None:
+        """_run_analysis must drop M2E markers from jdtls cached diagnostics."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import _run_analysis
+
+        m2e_diag = {
+            "code": "0",
+            "source": "org.eclipse.m2e",
+            "message": "Plugin execution not covered by lifecycle configuration",
+        }
+        real_diag = {
+            "code": "50",
+            "source": "jdtls",
+            "message": "The method foo() is undefined",
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 5}},
+            "severity": 1,
+        }
+
+        with patch("java_functional_lsp.server.server") as mock_server:
+            mock_server._proxy.is_available = True
+            mock_server._proxy.get_cached_diagnostics.return_value = [m2e_diag, real_diag]
+            mock_server._user_suppress_patterns = []
+            mock_server._config = {}
+            mock_server._parser = __import__("java_functional_lsp.analyzers.base", fromlist=["get_parser"]).get_parser()
+
+            result = _run_analysis("public class Foo {}", "file:///test/Foo.java")
+
+        codes = [str(d.code) for d in result if d.source == "jdtls"]
+        assert "0" not in codes, "M2E marker (code=0) should be filtered out"
+        assert "50" in codes, "Real jdtls diagnostic should still be present"

{java_functional_lsp-0.9.13 → java_functional_lsp-0.9.15}/uv.lock

@@ -184,7 +184,7 @@ wheels = [
 
 [[package]]
 name = "java-functional-lsp"
-version = "0.9.6"
+version = "0.9.14"
 source = { editable = "." }
 dependencies = [
     { name = "pygls" },

java_functional_lsp-0.9.13/.claude-plugin/plugin.json

@@ -1,5 +0,0 @@
-{
-  "name": "java-functional-lsp",
-  "description": "Java LSP with functional programming rules enforcement — null safety, immutability, no exceptions, Spring best practices. Wraps jdtls for full Java language support.",
-  "version": "0.4.1"
-}