java-functional-lsp 0.9.14__tar.gz → 0.9.16__tar.gz

java_functional_lsp-0.9.16/.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.14 → java_functional_lsp-0.9.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.14
+Version: 0.9.16
 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.14 → java_functional_lsp-0.9.16}/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.14 → java_functional_lsp-0.9.16}/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.14 → java_functional_lsp-0.9.16}/editors/intellij/README.md

@@ -84,7 +84,7 @@ The server automatically detects JetBrains IDEs and disables the jdtls proxy —
 ### No diagnostics appear
 - 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**
+- Try restarting the language server: **Language Servers** (search it in intellij Actions [Double Shift on keyboard]) → click on java-functional-lsp → **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

{java_functional_lsp-0.9.14 → java_functional_lsp-0.9.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.14"
+version = "0.9.16"
 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.14 → java_functional_lsp-0.9.16}/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.14"
+__version__ = "0.9.16"

{java_functional_lsp-0.9.14 → java_functional_lsp-0.9.16}/src/java_functional_lsp/cli.py

@@ -66,14 +66,41 @@ def format_diagnostic(path: Path, d: Diagnostic) -> str:
     return f"{path}:{d.line + 1}:{d.col}: [{sym}] {d.code}: {d.message}"
 
 
+_USAGE = """\
+Usage: java-functional-lsp check <file.java> [file2.java ...]
+       java-functional-lsp check --dir <directory>
+       java-functional-lsp          (start LSP server on stdio)"""
+
+
+def _collect_files(args: list[str]) -> list[Path]:
+    """Resolve CLI args to a list of .java paths."""
+    files: list[Path] = []
+    if args and args[0] == "--dir":
+        if len(args) < 2:
+            print("Error: --dir requires a directory path", file=sys.stderr)
+            sys.exit(1)
+        directory = Path(args[1])
+        if not directory.is_dir():
+            print(f"Error: {directory} is not a directory", file=sys.stderr)
+            sys.exit(1)
+        return sorted(directory.rglob("*.java"))
+    for arg in args:
+        p = Path(arg)
+        if p.is_file():
+            files.append(p)
+        elif p.is_dir():
+            files.extend(sorted(p.rglob("*.java")))
+        else:
+            print(f"Warning: {arg} not found, skipping", file=sys.stderr)
+    return files
+
+
 def main() -> None:
     """CLI entry point: java-functional-lsp check <files...>"""
     args = sys.argv[1:]
 
     if args and args[0] in ("-h", "--help"):
-        print("Usage: java-functional-lsp check <file.java> [file2.java ...]")
-        print("       java-functional-lsp check --dir <directory>")
-        print("       java-functional-lsp          (start LSP server on stdio)")
+        print(_USAGE)
         sys.exit(0)
 
     if not args or args[0] != "check":
@@ -85,34 +112,16 @@ def main() -> None:
 
     args = args[1:]  # skip "check"
 
-    # Collect files
-    files: list[Path] = []
-    if args and args[0] == "--dir":
-        if len(args) < 2:
-            print("Error: --dir requires a directory path", file=sys.stderr)
-            sys.exit(1)
-        directory = Path(args[1])
-        if not directory.is_dir():
-            print(f"Error: {directory} is not a directory", file=sys.stderr)
-            sys.exit(1)
-        files = sorted(directory.rglob("*.java"))
-    else:
-        for arg in args:
-            p = Path(arg)
-            if p.is_file():
-                files.append(p)
-            elif p.is_dir():
-                files.extend(sorted(p.rglob("*.java")))
-            else:
-                print(f"Warning: {arg} not found, skipping", file=sys.stderr)
+    if args and args[0] in ("-h", "--help"):
+        print(_USAGE)
+        sys.exit(0)
 
+    files = _collect_files(args)
     if not files:
         print("No .java files found", file=sys.stderr)
         sys.exit(1)
 
-    # Load config from first file's directory
     config = load_config(files[0])
-
     total_diags = 0
     excludes: list[str] = config.get("excludes", [])
     for path in files:

{java_functional_lsp-0.9.14 → java_functional_lsp-0.9.16}/tests/test_cli.py

@@ -4,8 +4,11 @@ from __future__ import annotations
 
 from pathlib import Path
 from typing import Any
+from unittest.mock import patch
 
-from java_functional_lsp.cli import check_file, format_diagnostic, load_config
+import pytest
+
+from java_functional_lsp.cli import check_file, format_diagnostic, load_config, main
 
 
 class TestCheckFile:
@@ -53,3 +56,26 @@ class TestLoadConfig:
     def test_missing_config(self, tmp_path: Path) -> None:
         config = load_config(tmp_path / "Test.java")
         assert config == {}
+
+
+class TestHelp:
+    def test_top_level_help(self, capsys: pytest.CaptureFixture[str]) -> None:
+        with patch("sys.argv", ["java-functional-lsp", "--help"]):
+            with pytest.raises(SystemExit) as exc:
+                main()
+        assert exc.value.code == 0
+        assert "check" in capsys.readouterr().out
+
+    def test_check_subcommand_help(self, capsys: pytest.CaptureFixture[str]) -> None:
+        with patch("sys.argv", ["java-functional-lsp", "check", "--help"]):
+            with pytest.raises(SystemExit) as exc:
+                main()
+        assert exc.value.code == 0
+        assert "check" in capsys.readouterr().out
+
+    def test_check_short_help(self, capsys: pytest.CaptureFixture[str]) -> None:
+        with patch("sys.argv", ["java-functional-lsp", "check", "-h"]):
+            with pytest.raises(SystemExit) as exc:
+                main()
+        assert exc.value.code == 0
+        assert "check" in capsys.readouterr().out

{java_functional_lsp-0.9.14 → java_functional_lsp-0.9.16}/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")
 
@@ -104,12 +109,17 @@ async def lsp_client(tmp_path: Any) -> LanguageClient:  # type: ignore[misc]
     try:
         yield client
     finally:
+        # Teardown with timeouts: the server subprocess may be mid-jdtls-startup
+        # on a slow CI runner, causing shutdown_async or stop to hang indefinitely.
         try:
-            await client.shutdown_async(None)
+            await asyncio.wait_for(client.shutdown_async(None), timeout=5.0)
             client.exit(None)
         except Exception:
             pass
-        await client.stop()
+        try:
+            await asyncio.wait_for(client.stop(), timeout=5.0)
+        except Exception:
+            pass
 
 
 async def _open_and_wait_for_diagnostics(
@@ -121,10 +131,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 +158,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 +2102,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."""
 

java_functional_lsp-0.9.14/.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"
-}