java-functional-lsp 0.8.0__tar.gz → 0.9.0__tar.gz

{java_functional_lsp-0.8.0 → java_functional_lsp-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.8.0
+Version: 0.9.0
 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
@@ -128,6 +128,8 @@ Use the [LSP4IJ](https://github.com/redhat-developer/lsp4ij) plugin (works on Co
 2. **Settings** → **Languages & Frameworks** → **Language Servers** → **`+`**
 3. Set **Command**: `java-functional-lsp`, then in **Mappings** → **File name patterns** add `*.java` with Language Id `java`
 
+The server automatically detects JetBrains IDEs and disables the jdtls proxy (IntelliJ provides native Java support). To force-enable jdtls, set `JAVA_FUNCTIONAL_LSP_JDTLS=on` in the server command environment.
+
 See [editors/intellij/README.md](editors/intellij/README.md) for detailed instructions.
 
 ### Claude Code

{java_functional_lsp-0.8.0 → java_functional_lsp-0.9.0}/README.md

@@ -100,6 +100,8 @@ Use the [LSP4IJ](https://github.com/redhat-developer/lsp4ij) plugin (works on Co
 2. **Settings** → **Languages & Frameworks** → **Language Servers** → **`+`**
 3. Set **Command**: `java-functional-lsp`, then in **Mappings** → **File name patterns** add `*.java` with Language Id `java`
 
+The server automatically detects JetBrains IDEs and disables the jdtls proxy (IntelliJ provides native Java support). To force-enable jdtls, set `JAVA_FUNCTIONAL_LSP_JDTLS=on` in the server command environment.
+
 See [editors/intellij/README.md](editors/intellij/README.md) for detailed instructions.
 
 ### Claude Code

{java_functional_lsp-0.8.0 → java_functional_lsp-0.9.0}/editors/intellij/README.md

@@ -73,7 +73,7 @@ Project-level rules are configured via `.java-functional-lsp.json` in your proje
 
 ## Coexistence with IntelliJ's Java Support
 
-LSP4IJ is designed to **supplement** IntelliJ's native Java support, not replace it. Your custom functional programming diagnostics appear alongside IntelliJ's built-in inspections. No conflicts.
+The server automatically detects JetBrains IDEs and disables the jdtls proxy — IntelliJ provides its own Java language features (completions, hover, go-to-definition, compile errors). Only the 16 custom functional programming rules run, and they appear alongside IntelliJ's built-in inspections.
 
 ## Troubleshooting
 
@@ -85,6 +85,7 @@ LSP4IJ is designed to **supplement** IntelliJ's native Java support, not replace
 - Ensure the file mapping is set to Language: `Java`, Language ID: `java`
 - Check that `.java-functional-lsp.json` doesn't have rules set to `"off"`
 - Try restarting the language server: **Tools** → **Language Servers** → **Restart**
+- If diagnostics worked before but stopped, the jdtls proxy may be interfering. Set `JAVA_FUNCTIONAL_LSP_JDTLS=off` in the server command environment to force-disable jdtls. The server auto-detects JetBrains IDEs and disables jdtls by default (since IntelliJ provides native Java support), but this can be overridden with `JAVA_FUNCTIONAL_LSP_JDTLS=on`.
 
 ### PATH not found
 - IntelliJ may not inherit your shell's PATH. Use the full absolute path to the binary in the server command.

{java_functional_lsp-0.8.0 → java_functional_lsp-0.9.0}/pyproject.toml

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

{java_functional_lsp-0.8.0 → java_functional_lsp-0.9.0}/src/java_functional_lsp/__init__.py

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

java_functional_lsp-0.9.0/src/java_functional_lsp/merkle.py

@@ -0,0 +1,222 @@
+"""Module snapshot tracking for incremental file-change detection between sessions.
+
+Each Java module's source files are hashed into a ``ModuleSnapshot``.
+On the next plugin session the stored snapshot is compared against the
+current one; only files that actually changed are forwarded to jdtls via
+``workspace/didChangeWatchedFiles``, letting it do an incremental rebuild
+instead of a full cold-start re-index.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import json
+import logging
+import os
+import tempfile
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Files and directories tracked / skipped during snapshot.
+_BUILD_FILES: frozenset[str] = frozenset({"pom.xml", "build.gradle", "build.gradle.kts"})
+_SKIP_DIRS: frozenset[str] = frozenset({"target", ".git", "node_modules", ".gradle", "build", ".idea", ".mvn"})
+
+# Safety bound: modules larger than this are skipped to prevent multi-second
+# executor stalls (e.g., when jdtls is scoped to the monorepo root).
+_MAX_FILES = 20_000
+
+# Upper bound on entries in a persisted snapshot (sanity / DoS guard).
+_MAX_SNAPSHOT_FILES = 100_000
+
+_READ_CHUNK = 65536  # 64 KiB per read — bounds per-file memory usage during hashing
+
+
+def _blake2b_file(path: Path) -> str:
+    """Return a 64-char BLAKE2b hex digest of *path*, reading in 64 KiB chunks.
+
+    Streams the file instead of loading it entirely into memory, bounding
+    per-file heap usage to ``_READ_CHUNK`` bytes regardless of file size.
+    """
+    h = hashlib.blake2b(digest_size=32)
+    with path.open("rb") as fh:
+        while chunk := fh.read(_READ_CHUNK):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+@dataclass(frozen=True)
+class TreeDiff:
+    """Set-based diff between two ``ModuleSnapshot`` instances."""
+
+    added: frozenset[str]
+    modified: frozenset[str]
+    removed: frozenset[str]
+
+    @property
+    def is_empty(self) -> bool:
+        return not (self.added or self.modified or self.removed)
+
+    @property
+    def has_build_file_changes(self) -> bool:
+        """True if any build file (pom.xml, build.gradle, …) changed."""
+        return any(Path(p).name in _BUILD_FILES for bucket in (self.added, self.modified, self.removed) for p in bucket)
+
+    @property
+    def all_changed(self) -> frozenset[str]:
+        """Union of added and modified relative paths (files present on disk)."""
+        return self.added | self.modified
+
+
+@dataclass
+class ModuleSnapshot:
+    """Snapshot of a Java module's tracked source files.
+
+    ``root_hash`` is a BLAKE2b hash of all ``(relative_path, content_hash)``
+    pairs sorted by path.  Two snapshots with the same ``root_hash`` are
+    identical; this enables an O(1) equality check before the O(N) per-file
+    diff.
+
+    ``files`` maps each tracked relative path to the BLAKE2b hash of its
+    content at snapshot time.
+    """
+
+    root_hash: str
+    files: dict[str, str]  # relative path → content hash
+
+    # ------------------------------------------------------------------
+    # Construction
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def build(cls, module_root: Path) -> ModuleSnapshot | None:
+        """Scan *module_root* and return a snapshot, or ``None`` if too large.
+
+        Tracked files: ``*.java`` + ``pom.xml`` / ``build.gradle`` /
+        ``build.gradle.kts``.  Directories in ``_SKIP_DIRS`` (``target``,
+        ``.git``, ``node_modules``, …) are pruned from the walk entirely.
+        Symlinks are skipped.  Paths that resolve outside *module_root* are
+        rejected (defense-in-depth against directory traversal).
+        """
+        files: dict[str, str] = {}
+
+        for file_path in _iter_tracked_files(module_root):
+            if len(files) >= _MAX_FILES:
+                logger.warning(
+                    "merkle: module %s has ≥%d tracked files — skipping snapshot",
+                    module_root,
+                    _MAX_FILES,
+                )
+                return None
+            rel = str(file_path.relative_to(module_root))
+            try:
+                files[rel] = _blake2b_file(file_path)
+            except OSError as exc:
+                logger.debug("merkle: could not read %s: %s", file_path, exc)
+
+        # Build root hash incrementally — avoids allocating an O(N) intermediate string.
+        h = hashlib.blake2b(digest_size=32)
+        for p, fh in sorted(files.items()):
+            h.update(f"{p}:{fh}\n".encode())
+        return cls(root_hash=h.hexdigest(), files=files)
+
+    # ------------------------------------------------------------------
+    # Comparison
+    # ------------------------------------------------------------------
+
+    def diff(self, newer: ModuleSnapshot) -> TreeDiff:
+        """Return what changed between *self* (old) and *newer* (current)."""
+        old = self.files
+        new = newer.files
+        added = frozenset(new.keys() - old.keys())
+        removed = frozenset(old.keys() - new.keys())
+        modified = frozenset(p for p in old.keys() & new.keys() if old[p] != new[p])
+        return TreeDiff(added=added, modified=modified, removed=removed)
+
+    # ------------------------------------------------------------------
+    # Persistence
+    # ------------------------------------------------------------------
+
+    def save(self, path: Path) -> None:
+        """Atomically write snapshot to *path* (write to temp then rename).
+
+        The parent directory is created with mode ``0o700`` (owner-only) on
+        first use to prevent other local users from tampering with the cache.
+        """
+        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        payload = json.dumps({"root": self.root_hash, "files": self.files}, separators=(",", ":"))
+        fd, tmp = tempfile.mkstemp(dir=path.parent, suffix=".tmp")
+        try:
+            with os.fdopen(fd, "wb") as fh:
+                fh.write(payload.encode())
+            os.replace(tmp, path)
+        except Exception:
+            with contextlib.suppress(OSError):
+                os.unlink(tmp)
+            raise
+
+    @classmethod
+    def load(cls, path: Path) -> ModuleSnapshot | None:
+        """Load a snapshot from *path*.
+
+        Returns ``None`` on missing file, JSON parse error, or invalid
+        content (path traversal attempts, oversized entries, wrong types).
+        Never raises.
+        """
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            root_hash = data["root"]
+            files = data["files"]
+            if not isinstance(root_hash, str) or not isinstance(files, dict):
+                return None
+            if len(files) > _MAX_SNAPSHOT_FILES:
+                return None
+            # Validate each entry: relative, no traversal, no nulls, str values.
+            valid = all(
+                isinstance(k, str)
+                and isinstance(v, str)
+                and "\x00" not in k
+                and not (p := Path(k)).is_absolute()
+                and ".." not in p.parts
+                for k, v in files.items()
+            )
+            return cls(root_hash=root_hash, files=files) if valid else None
+        except (OSError, KeyError, ValueError):
+            return None
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _iter_tracked_files(module_root: Path) -> Iterator[Path]:
+    """Yield ``.java`` and build files under *module_root*.
+
+    Uses ``os.walk`` with ``followlinks=False`` and prunes ``_SKIP_DIRS``
+    in-place so entire subtrees (``target/``, ``.git/``, …) are never
+    entered.  Symlink files are skipped individually.  Any path that resolves
+    outside *module_root* after symlink expansion is rejected.
+    """
+    module_resolved = module_root.resolve()
+
+    for dirpath_str, dirnames, filenames in os.walk(module_root, followlinks=False):
+        # Prune skip dirs in-place to stop os.walk from descending into them.
+        dirnames[:] = [d for d in dirnames if d not in _SKIP_DIRS]
+
+        dir_path = Path(dirpath_str)
+        for fname in filenames:
+            if not (fname.endswith(".java") or fname in _BUILD_FILES):
+                continue
+            file_path = dir_path / fname
+            if file_path.is_symlink():
+                continue
+            # Reject any path whose resolved form escapes the module root.
+            try:
+                file_path.resolve().relative_to(module_resolved)
+            except ValueError:
+                continue
+            yield file_path

{java_functional_lsp-0.8.0 → java_functional_lsp-0.9.0}/src/java_functional_lsp/proxy.py

@@ -19,6 +19,8 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
+from .merkle import _BUILD_FILES, ModuleSnapshot, TreeDiff
+
 logger = logging.getLogger(__name__)
 
 REQUEST_TIMEOUT = 30.0  # seconds — per-request timeout for normal operations
@@ -317,7 +319,6 @@ async def read_message(reader: asyncio.StreamReader) -> dict[str, Any] | None:
         return None
 
 
-_BUILD_FILES = ("pom.xml", "build.gradle", "build.gradle.kts")
 _WORKSPACE_DID_CHANGE_FOLDERS = "workspace/didChangeWorkspaceFolders"
 _MAX_QUEUED_NOTIFICATIONS = 200
 _MODULE_READY_TIMEOUT = 30.0
@@ -430,7 +431,7 @@ def _resolve_module_uri(file_uri: str) -> str | None:
     if module_root is None:
         return None
     module_uri = from_fs_path(module_root)
-    return module_uri or None
+    return module_uri if module_uri else None
 
 
 def _version_key(name: str) -> tuple[int, ...]:
@@ -444,6 +445,55 @@ def _version_key(name: str) -> tuple[int, ...]:
     return tuple(parts)
 
 
+@lru_cache(maxsize=256)
+def _module_snapshot_path(module_uri: str) -> Path:
+    """Return the path for the persistent snapshot file for *module_uri*.
+
+    Snapshots live under ``~/.cache/jdtls-snapshots/`` — separate from the
+    jdtls data-dir tree so they survive version-bump cache wipes.
+    Each module gets a 12-char BLAKE2b subdirectory (6-byte digest).
+    """
+    h = hashlib.blake2b(module_uri.encode(), digest_size=6).hexdigest()
+    return Path.home() / ".cache" / "jdtls-snapshots" / h / ".snapshot.json"
+
+
+def _compute_module_diff(
+    module_uri: str,
+) -> tuple[TreeDiff | None, ModuleSnapshot] | None:
+    """Blocking: build current snapshot and diff against stored one.
+
+    Returns ``(diff, current_snapshot)`` or ``None`` on error / size limit.
+    ``diff`` is ``None`` when there is no stored snapshot (first session) or
+    the snapshots are identical — the caller should still save the snapshot in
+    both cases.
+
+    Intended to run inside a thread-pool executor.
+    """
+    from pygls.uris import to_fs_path
+
+    module_fs = to_fs_path(module_uri)
+    if not module_fs:
+        return None
+    module_root = Path(module_fs)
+    if not module_root.is_dir():
+        return None
+
+    current = ModuleSnapshot.build(module_root)
+    if current is None:
+        return None  # file count exceeded limit
+
+    snapshot_path = _module_snapshot_path(module_uri)
+    stored = ModuleSnapshot.load(snapshot_path)
+
+    if stored is None:
+        # First session: no diff to compute — caller (_apply_module_diff) will
+        # save the baseline snapshot after the module reaches READY.
+        return (None, current)
+
+    diff = stored.diff(current)
+    return (diff, current)
+
+
 def _clear_cache_on_version_change(cache_root: Path) -> None:
     """Clear jdtls data cache when the server version changes.
 
@@ -534,6 +584,16 @@ class JdtlsProxy:
         self.modules = ModuleRegistry()
         self.has_lombok = False
         self._workspace_expanded = False
+        # Merkle snapshot diff: module_uri → (diff | None, current_snapshot)
+        # Populated by _kick_module_diff (background task on add_module_if_new).
+        # Consumed by server._apply_module_diff after module reaches READY.
+        self._module_diff_results: dict[str, tuple[TreeDiff | None, ModuleSnapshot]] = {}
+        # Task references for in-flight diff computations, keyed by module_uri.
+        # Allows _apply_module_diff to await the task directly if READY fires
+        # before _kick_module_diff stores its result.
+        self._pending_diff_tasks: dict[str, asyncio.Task[None]] = {}
+        # Background tasks created by this proxy (prevents GC of fire-and-forget tasks).
+        self._proxy_bg_tasks: set[asyncio.Task[Any]] = set()
 
     @property
     def is_available(self) -> bool:
@@ -726,6 +786,42 @@ class JdtlsProxy:
         for method, params in queue:
             await self.send_notification(method, params)
 
+    async def _kick_module_diff(self, module_uri: str) -> None:
+        """Background task: compute snapshot diff and stash it for later use.
+
+        Result is stored in ``_module_diff_results`` BEFORE the task is removed
+        from ``_pending_diff_tasks`` to eliminate the TOCTOU window where
+        ``await_module_diff`` could find neither a running task nor a result.
+        """
+        loop = asyncio.get_running_loop()
+        result = await loop.run_in_executor(None, _compute_module_diff, module_uri)
+        # Store result first, then remove from pending — preserves invariant that
+        # once the task is gone from _pending_diff_tasks the result is already readable.
+        if result is not None:
+            self._module_diff_results[module_uri] = result
+        self._pending_diff_tasks.pop(module_uri, None)
+
+    def pop_module_data(self, module_uri: str) -> tuple[TreeDiff | None, ModuleSnapshot] | None:
+        """Pop and return stashed ``(diff, snapshot)`` for *module_uri*, or ``None``."""
+        return self._module_diff_results.pop(module_uri, None)
+
+    async def await_module_diff(self, module_uri: str) -> None:
+        """Wait for the in-flight diff task for *module_uri* to complete, if any.
+
+        Called when the READY signal fires before ``_kick_module_diff`` has
+        stored its result — awaiting the task directly avoids a time-based
+        sleep and ensures the diff is never silently dropped.
+
+        Swallows ``CancelledError`` so that a ``stop()`` call during the wait
+        does not propagate and crash the caller.
+        """
+        task = self._pending_diff_tasks.pop(module_uri, None)
+        if task is not None and not task.done():
+            try:
+                await task
+            except (asyncio.CancelledError, Exception):
+                pass  # result storage is _kick_module_diff's responsibility
+
     async def add_module_if_new(self, file_uri: str) -> str | None:
         """Add the module containing *file_uri* to jdtls if not already added.
 
@@ -751,6 +847,13 @@ class JdtlsProxy:
             _WORKSPACE_DID_CHANGE_FOLDERS,
             {"event": {"added": [{"uri": module_uri, "name": mod_name}], "removed": []}},
         )
+        # Fire-and-forget: compute snapshot diff in background so it is ready
+        # when the module reaches READY state.  Does NOT block the jdtls
+        # readiness timeout (which starts ticking at mark_added above).
+        diff_task = asyncio.create_task(self._kick_module_diff(module_uri))
+        self._proxy_bg_tasks.add(diff_task)
+        diff_task.add_done_callback(self._proxy_bg_tasks.discard)
+        self._pending_diff_tasks[module_uri] = diff_task
         return module_uri
 
     async def expand_full_workspace(self) -> None:
@@ -792,6 +895,12 @@ class JdtlsProxy:
         if self._stderr_task and not self._stderr_task.done():
             self._stderr_task.cancel()
 
+        for task in list(self._proxy_bg_tasks):
+            task.cancel()
+        self._proxy_bg_tasks.clear()
+        self._module_diff_results.clear()
+        self._pending_diff_tasks.clear()
+
         if self._process and self._process.returncode is None:
             try:
                 await self.send_request("shutdown", None, timeout=5.0)