java-functional-lsp 0.11.0__tar.gz → 0.11.2__tar.gz

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.11.0
+Version: 0.11.2
 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
@@ -36,7 +36,7 @@ Description-Content-Type: text/markdown
 A Java Language Server that provides three things in one:
 
 1. **Full Java language support** — completions, hover, go-to-definition, compile errors, missing imports — by proxying [Eclipse jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) under the hood
-2. **16 functional programming rules** — catches anti-patterns and suggests Vavr/Lombok/Spring alternatives, all before compilation
+2. **17 functional programming rules** — catches anti-patterns and suggests Vavr/Lombok/Spring alternatives, all before compilation
 3. **Code actions (quick fixes)** — automated refactoring via LSP `textDocument/codeAction`, with machine-readable diagnostic metadata for AI agents
 
 Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
@@ -52,7 +52,7 @@ When [jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) is installed, the
 - Type mismatches
 - Completions, hover, go-to-definition, find references
 
-Install jdtls separately: `brew install jdtls` (requires JDK 21+). The server auto-detects a Java 21+ installation even when the IDE's project SDK is older (e.g., Java 8) by probing `JDTLS_JAVA_HOME`, `JAVA_HOME`, `/usr/libexec/java_home -v 21+` (macOS), and `java` on PATH. Without jdtls, the server runs in standalone mode — the 16 custom rules still work, but you won't get compile errors or completions.
+Install jdtls separately: `brew install jdtls` (requires JDK 21+). The server auto-detects a Java 21+ installation even when the IDE's project SDK is older (e.g., Java 8) by probing `JDTLS_JAVA_HOME`, `JAVA_HOME`, `/usr/libexec/java_home -v 21+` (macOS), and `java` on PATH. Without jdtls, the server runs in standalone mode — the 17 custom rules still work, but you won't get compile errors or completions.
 
 ### Functional programming rules
 
@@ -66,14 +66,15 @@ Install jdtls separately: `brew install jdtls` (requires JDK 21+). The server au
 | `catch-rethrow` | catch block that wraps + rethrows | `Try.of().toEither()` | — |
 | `mutable-variable` | Local variable reassignment | Final variables + functional transforms | — |
 | `imperative-loop` | `for`/`while` loops | `.map()`/`.filter()`/`.flatMap()`/`.foldLeft()` | — |
-| `mutable-dto` | `@Data` or `@Setter` on class | `@Value` (immutable) | — |
-| `imperative-option-unwrap` | `if (opt.isDefined()) { opt.get() }` | `map()`/`flatMap()`/`fold()` | — |
+| `mutable-dto` | `@Data` or `@Setter` on class | `@Value` (immutable) | ✅ |
+| `imperative-option-unwrap` | `if (opt.isDefined()) { opt.get() }` | `map()`/`flatMap()`/`fold()` | ✅ |
 | `field-injection` | `@Autowired` on field | Constructor injection | — |
 | `component-annotation` | `@Component`/`@Service`/`@Repository` | `@Configuration` + `@Bean` | — |
 | `frozen-mutation` | Mutation on `List.of()`/`Collections.unmodifiable*` | `io.vavr.collection.List` | ✅ |
 | `null-check-to-monadic` | `if (x != null) { return x.foo(); }` | `Option.of(x).map(...)` | ✅ |
 | `try-catch-to-monadic` | `try { return x(); } catch (E e) { return d; }` | `Try.of(() -> x()).getOrElse(d)` | ✅ |
-| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` | — |
+| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` / return `Either.left` instead of throwing | — |
+| `option-map-nullable` | `Option.map(x -> x.get(k))` followed by chained call (`Some(null)` risk) | `.flatMap(x -> Option.of(...))` | — |
 
 ## Install
 
@@ -157,7 +158,30 @@ Add `lspServers` to `~/.claude/settings.json` (the plugin handles this automatic
 claude plugin add https://github.com/aviadshiber/java-functional-lsp.git
 ```
 
-This registers the LSP server, adds auto-install hooks, a PostToolUse hook that reminds Claude to fix violations on every `.java` file edit, and the `/lint-java` command.
+This registers the LSP server, adds auto-install hooks, a PostToolUse hook that lints every `.java` file after Edit/Write and feeds the violations back to Claude as context (plus a reminder hook on Read), and the `/lint-java` command.
+
+**Manual hook setup (without the plugin)** — add the lint hook to `~/.claude/settings.json`, pointing at a checkout of this repo:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|MultiEdit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 /path/to/java-functional-lsp/hooks/post_tool_lint.py",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+The hook is failure-safe: it only fires on `.java` files, lints just the edited file (well under 2s), stays silent when the file is clean, and always exits 0 so a linter problem can never break the editing session.
 
 Or manually add to your Claude Code config:
 
@@ -341,8 +365,10 @@ The server provides LSP code actions (`textDocument/codeAction`) that automatica
 | `null-check-to-monadic` | Convert to Option monadic flow | Rewrites `if (x != null) { return x.foo(); }` → `Option.of(x).map(...)`, supports chained fallbacks via `.orElse()`, adds import |
 | `null-return` | Replace with Option.none() | Rewrites `return null` → `return Option.none()`, adds import |
 | `try-catch-to-monadic` | Convert try/catch to Try monadic flow | Rewrites `try { return expr; } catch (E e) { return default; }` → `Try.of(() -> expr).getOrElse(default)`. Supports 3 patterns: simple default (eager/lazy `.getOrElse`), logging + default (`.onFailure().getOrElse`), and exception-dependent recovery (`.recover(E.class, ...).get()`). Skips try-with-resources, finally, multi-catch, and union types. Adds import. |
+| `imperative-option-unwrap` | Convert to Option.map().getOrElse() | Rewrites `if (opt.isDefined()) return opt.get(); else return X;` → `return opt.map(it -> ...).getOrElse(X);` (lazy `getOrElse(() -> ...)` for non-eager defaults). Bails on missing else or complex bodies. |
+| `mutable-dto` | Replace @Data with @Value | Replaces the `@Data` annotation with `@Value` and adds `import lombok.Value`. Skips `@Setter`, `@ConfigurationProperties`, and conflicting Lombok constructor annotations. |
 
-Quick fixes automatically add the required Vavr import if it's not already present. Disable auto-import with `"autoImportVavr": false` in config.
+Quick fixes automatically add the required Vavr import if it's not already present. Disable auto-import with `"autoImportVavr": false` in config (`"autoImportLombok": false` for the Lombok import added by the `mutable-dto` fix).
 
 ## Agent mode (AI integration)
 
@@ -355,12 +381,14 @@ Every diagnostic includes a machine-readable `data` payload designed for AI agen
   "data": {
     "fixType": "REPLACE_WITH_VAVR_LIST",
     "targetLibrary": "io.vavr.collection.List",
-    "rationale": "Runtime mutation of List.of() causes UnsupportedOperationException. Use Vavr for safe, persistent immutability."
+    "rationale": "Runtime mutation of List.of() causes UnsupportedOperationException. Use Vavr for safe, persistent immutability.",
+    "recommendedApi": ".append / .appendAll / .update / .remove (returns a new persistent collection)",
+    "suggestedSnippet": "list = list.append(\"c\");  // returns a new persistent collection"
   }
 }
 ```
 
-This lets agents confidently apply fixes without guessing libraries or patterns — the `fixType` tells them *what* to do, `targetLibrary` tells them *which dependency*, and `rationale` tells them *why*.
+This lets agents confidently apply fixes without guessing libraries or patterns — the `fixType` tells them *what* to do, `targetLibrary` tells them *which dependency*, and `rationale` tells them *why*. `recommendedApi` names the exact method on the target library (e.g. Vavr `Option` uses `forEach`, **not** `ifPresent`) and `suggestedSnippet` is a paste-able fix built from the real AST variable names.
 
 **Agent mode configuration** in `.java-functional-lsp.json`:
 
@@ -374,6 +402,7 @@ This lets agents confidently apply fixes without guessing libraries or patterns
 | Key | Default | Effect |
 |-----|---------|--------|
 | `autoImportVavr` | `true` | Quick fixes auto-add Vavr/Option imports |
+| `autoImportLombok` | `true` | The `mutable-dto` quick fix auto-adds `import lombok.Value` |
 | `strictPurity` | `false` | When `true`, `impure-method` uses WARNING severity instead of HINT |
 
 > **Note:** The machine-readable `data` payload is always included in diagnostics when available — no configuration needed.

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/README.md

@@ -8,7 +8,7 @@
 A Java Language Server that provides three things in one:
 
 1. **Full Java language support** — completions, hover, go-to-definition, compile errors, missing imports — by proxying [Eclipse jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) under the hood
-2. **16 functional programming rules** — catches anti-patterns and suggests Vavr/Lombok/Spring alternatives, all before compilation
+2. **17 functional programming rules** — catches anti-patterns and suggests Vavr/Lombok/Spring alternatives, all before compilation
 3. **Code actions (quick fixes)** — automated refactoring via LSP `textDocument/codeAction`, with machine-readable diagnostic metadata for AI agents
 
 Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
@@ -24,7 +24,7 @@ When [jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) is installed, the
 - Type mismatches
 - Completions, hover, go-to-definition, find references
 
-Install jdtls separately: `brew install jdtls` (requires JDK 21+). The server auto-detects a Java 21+ installation even when the IDE's project SDK is older (e.g., Java 8) by probing `JDTLS_JAVA_HOME`, `JAVA_HOME`, `/usr/libexec/java_home -v 21+` (macOS), and `java` on PATH. Without jdtls, the server runs in standalone mode — the 16 custom rules still work, but you won't get compile errors or completions.
+Install jdtls separately: `brew install jdtls` (requires JDK 21+). The server auto-detects a Java 21+ installation even when the IDE's project SDK is older (e.g., Java 8) by probing `JDTLS_JAVA_HOME`, `JAVA_HOME`, `/usr/libexec/java_home -v 21+` (macOS), and `java` on PATH. Without jdtls, the server runs in standalone mode — the 17 custom rules still work, but you won't get compile errors or completions.
 
 ### Functional programming rules
 
@@ -38,14 +38,15 @@ Install jdtls separately: `brew install jdtls` (requires JDK 21+). The server au
 | `catch-rethrow` | catch block that wraps + rethrows | `Try.of().toEither()` | — |
 | `mutable-variable` | Local variable reassignment | Final variables + functional transforms | — |
 | `imperative-loop` | `for`/`while` loops | `.map()`/`.filter()`/`.flatMap()`/`.foldLeft()` | — |
-| `mutable-dto` | `@Data` or `@Setter` on class | `@Value` (immutable) | — |
-| `imperative-option-unwrap` | `if (opt.isDefined()) { opt.get() }` | `map()`/`flatMap()`/`fold()` | — |
+| `mutable-dto` | `@Data` or `@Setter` on class | `@Value` (immutable) | ✅ |
+| `imperative-option-unwrap` | `if (opt.isDefined()) { opt.get() }` | `map()`/`flatMap()`/`fold()` | ✅ |
 | `field-injection` | `@Autowired` on field | Constructor injection | — |
 | `component-annotation` | `@Component`/`@Service`/`@Repository` | `@Configuration` + `@Bean` | — |
 | `frozen-mutation` | Mutation on `List.of()`/`Collections.unmodifiable*` | `io.vavr.collection.List` | ✅ |
 | `null-check-to-monadic` | `if (x != null) { return x.foo(); }` | `Option.of(x).map(...)` | ✅ |
 | `try-catch-to-monadic` | `try { return x(); } catch (E e) { return d; }` | `Try.of(() -> x()).getOrElse(d)` | ✅ |
-| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` | — |
+| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` / return `Either.left` instead of throwing | — |
+| `option-map-nullable` | `Option.map(x -> x.get(k))` followed by chained call (`Some(null)` risk) | `.flatMap(x -> Option.of(...))` | — |
 
 ## Install
 
@@ -129,7 +130,30 @@ Add `lspServers` to `~/.claude/settings.json` (the plugin handles this automatic
 claude plugin add https://github.com/aviadshiber/java-functional-lsp.git
 ```
 
-This registers the LSP server, adds auto-install hooks, a PostToolUse hook that reminds Claude to fix violations on every `.java` file edit, and the `/lint-java` command.
+This registers the LSP server, adds auto-install hooks, a PostToolUse hook that lints every `.java` file after Edit/Write and feeds the violations back to Claude as context (plus a reminder hook on Read), and the `/lint-java` command.
+
+**Manual hook setup (without the plugin)** — add the lint hook to `~/.claude/settings.json`, pointing at a checkout of this repo:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|MultiEdit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 /path/to/java-functional-lsp/hooks/post_tool_lint.py",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+The hook is failure-safe: it only fires on `.java` files, lints just the edited file (well under 2s), stays silent when the file is clean, and always exits 0 so a linter problem can never break the editing session.
 
 Or manually add to your Claude Code config:
 
@@ -313,8 +337,10 @@ The server provides LSP code actions (`textDocument/codeAction`) that automatica
 | `null-check-to-monadic` | Convert to Option monadic flow | Rewrites `if (x != null) { return x.foo(); }` → `Option.of(x).map(...)`, supports chained fallbacks via `.orElse()`, adds import |
 | `null-return` | Replace with Option.none() | Rewrites `return null` → `return Option.none()`, adds import |
 | `try-catch-to-monadic` | Convert try/catch to Try monadic flow | Rewrites `try { return expr; } catch (E e) { return default; }` → `Try.of(() -> expr).getOrElse(default)`. Supports 3 patterns: simple default (eager/lazy `.getOrElse`), logging + default (`.onFailure().getOrElse`), and exception-dependent recovery (`.recover(E.class, ...).get()`). Skips try-with-resources, finally, multi-catch, and union types. Adds import. |
+| `imperative-option-unwrap` | Convert to Option.map().getOrElse() | Rewrites `if (opt.isDefined()) return opt.get(); else return X;` → `return opt.map(it -> ...).getOrElse(X);` (lazy `getOrElse(() -> ...)` for non-eager defaults). Bails on missing else or complex bodies. |
+| `mutable-dto` | Replace @Data with @Value | Replaces the `@Data` annotation with `@Value` and adds `import lombok.Value`. Skips `@Setter`, `@ConfigurationProperties`, and conflicting Lombok constructor annotations. |
 
-Quick fixes automatically add the required Vavr import if it's not already present. Disable auto-import with `"autoImportVavr": false` in config.
+Quick fixes automatically add the required Vavr import if it's not already present. Disable auto-import with `"autoImportVavr": false` in config (`"autoImportLombok": false` for the Lombok import added by the `mutable-dto` fix).
 
 ## Agent mode (AI integration)
 
@@ -327,12 +353,14 @@ Every diagnostic includes a machine-readable `data` payload designed for AI agen
   "data": {
     "fixType": "REPLACE_WITH_VAVR_LIST",
     "targetLibrary": "io.vavr.collection.List",
-    "rationale": "Runtime mutation of List.of() causes UnsupportedOperationException. Use Vavr for safe, persistent immutability."
+    "rationale": "Runtime mutation of List.of() causes UnsupportedOperationException. Use Vavr for safe, persistent immutability.",
+    "recommendedApi": ".append / .appendAll / .update / .remove (returns a new persistent collection)",
+    "suggestedSnippet": "list = list.append(\"c\");  // returns a new persistent collection"
   }
 }
 ```
 
-This lets agents confidently apply fixes without guessing libraries or patterns — the `fixType` tells them *what* to do, `targetLibrary` tells them *which dependency*, and `rationale` tells them *why*.
+This lets agents confidently apply fixes without guessing libraries or patterns — the `fixType` tells them *what* to do, `targetLibrary` tells them *which dependency*, and `rationale` tells them *why*. `recommendedApi` names the exact method on the target library (e.g. Vavr `Option` uses `forEach`, **not** `ifPresent`) and `suggestedSnippet` is a paste-able fix built from the real AST variable names.
 
 **Agent mode configuration** in `.java-functional-lsp.json`:
 
@@ -346,6 +374,7 @@ This lets agents confidently apply fixes without guessing libraries or patterns
 | Key | Default | Effect |
 |-----|---------|--------|
 | `autoImportVavr` | `true` | Quick fixes auto-add Vavr/Option imports |
+| `autoImportLombok` | `true` | The `mutable-dto` quick fix auto-adds `import lombok.Value` |
 | `strictPurity` | `false` | When `true`, `impure-method` uses WARNING severity instead of HINT |
 
 > **Note:** The machine-readable `data` payload is always included in diagnostics when available — no configuration needed.

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: java-functional-lsp
-description: Java LSP with full language support (completions, hover, go-to-def, compile errors) plus 16 functional programming rules with automated quick fixes. Auto-invoke when setting up Java language support or discussing Java linting configuration.
+description: Java LSP with full language support (completions, hover, go-to-def, compile errors) plus 17 functional programming rules with automated quick fixes. Auto-invoke when setting up Java language support or discussing Java linting configuration.
 allowed-tools: Bash
 disable-model-invocation: true
 ---
 
 # Java Functional LSP
 
-A Java LSP server that wraps jdtls and adds 16 functional programming rules with code actions (quick fixes). Gives you **full Java language support** (completions, hover, go-to-def, compile errors) **plus** custom diagnostics with machine-readable metadata for AI agents — all before compilation.
+A Java LSP server that wraps jdtls and adds 17 functional programming rules with code actions (quick fixes). Gives you **full Java language support** (completions, hover, go-to-def, compile errors) **plus** custom diagnostics with machine-readable metadata for AI agents — all before compilation.
 
 ## Prerequisites
 
@@ -22,7 +22,7 @@ brew install jdtls
 
 Without jdtls, the server runs in standalone mode — custom rules still work, but no completions/hover/compile errors.
 
-## Rules (16 checks)
+## Rules (17 checks)
 
 | Rule | Detects | Suggests | Quick Fix |
 |------|---------|----------|-----------|
@@ -34,14 +34,15 @@ Without jdtls, the server runs in standalone mode — custom rules still work, b
 | `catch-rethrow` | catch wraps + rethrows | `Try.of().toEither()` | — |
 | `mutable-variable` | Variable reassignment | Final + functional transforms | — |
 | `imperative-loop` | `for`/`while` loops | `.map()`/`.filter()`/`.flatMap()` | — |
-| `mutable-dto` | `@Data` or `@Setter` | `@Value` (immutable) | — |
-| `imperative-option-unwrap` | `if (opt.isDefined()) { opt.get() }` | `map()`/`flatMap()`/`fold()` | — |
+| `mutable-dto` | `@Data` or `@Setter` | `@Value` (immutable) | ✅ |
+| `imperative-option-unwrap` | `if (opt.isDefined()) { opt.get() }` | `map()`/`flatMap()`/`fold()` | ✅ |
 | `field-injection` | `@Autowired` on field | Constructor injection | — |
 | `component-annotation` | `@Component`/`@Service`/`@Repository` | `@Configuration` + `@Bean` | — |
 | `frozen-mutation` | Mutation on `List.of()`/`Collections.unmodifiable*` | `io.vavr.collection.List` | ✅ |
 | `null-check-to-monadic` | `if (x != null) { return x.foo(); }` | `Option.of(x).map(...)` | ✅ |
 | `try-catch-to-monadic` | `try { return x(); } catch (E e) { return d; }` | `Try.of(() -> x()).getOrElse(d)` | ✅ |
-| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` | — |
+| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` / return `Either.left` instead of throwing | — |
+| `option-map-nullable` | `Option.map(x -> x.get(k))` followed by chained call (`Some(null)` risk) | `.flatMap(x -> Option.of(...))` | — |
 
 ## Code Actions (Quick Fixes)
 
@@ -51,6 +52,8 @@ Rules marked ✅ provide automated `textDocument/codeAction` fixes:
 - **null-check-to-monadic** → "Convert to Option monadic flow" — rewrites `if (x != null)` to `Option.of(x).map(...)`, supports chained fallbacks via `.orElse()`, adds import
 - **null-return** → "Replace with Option.none()" — replaces `null` with `Option.none()`, adds import
 - **try-catch-to-monadic** → "Convert try/catch to Try monadic flow" — rewrites `try { return expr; } catch (E e) { return default; }` to `Try.of(() -> expr).getOrElse(default)`. Supports 3 patterns: simple default, logging + default (`.onFailure().getOrElse`), and exception-dependent recovery (`.recover(E.class, ...).get()`). Skips try-with-resources, finally, multi-catch, union types. Adds import.
+- **imperative-option-unwrap** → "Convert to Option.map().getOrElse()" — rewrites `if (opt.isDefined()) return opt.get(); else return X;` to `return opt.map(it -> ...).getOrElse(X);` (lazy supplier for non-eager defaults). Bails on missing else or complex bodies.
+- **mutable-dto** → "Replace @Data with @Value" — swaps the annotation and adds `import lombok.Value` (disable with `"autoImportLombok": false`). Skips `@Setter`, `@ConfigurationProperties`, and conflicting Lombok constructor annotations.
 
 ## Agent-Ready Diagnostics
 
@@ -60,11 +63,13 @@ Every diagnostic includes a machine-readable `data` payload:
 {
   "fixType": "REPLACE_WITH_VAVR_LIST",
   "targetLibrary": "io.vavr.collection.List",
-  "rationale": "Runtime mutation of List.of() causes UnsupportedOperationException."
+  "rationale": "Runtime mutation of List.of() causes UnsupportedOperationException.",
+  "recommendedApi": ".append / .appendAll / .update / .remove (returns a new persistent collection)",
+  "suggestedSnippet": "list = list.append(\"c\");  // returns a new persistent collection"
 }
 ```
 
-This lets AI agents apply fixes with confidence — `fixType` says what to do, `targetLibrary` says which dependency, `rationale` says why.
+This lets AI agents apply fixes with confidence — `fixType` says what to do, `targetLibrary` says which dependency, `rationale` says why, `recommendedApi` names the exact method (e.g. Vavr `Option` uses `forEach`, not `ifPresent`), and `suggestedSnippet` is a paste-able fix built from real AST variable names.
 
 ## Configuration
 
@@ -93,7 +98,10 @@ Create `.java-functional-lsp.json` in your project root:
 
 ## Automatic Enforcement
 
-The plugin includes a PostToolUse hook that fires on every Read/Edit/Write of `.java` files. If diagnostics appear, Claude is prompted to fix them immediately without explanation.
+The plugin includes two PostToolUse hooks:
+
+- **Edit/MultiEdit/Write** → `hooks/post_tool_lint.py` lints the edited `.java` file (single-file, <2s) and injects any violations into Claude's context so they get fixed immediately. Silent on clean files; internal errors are swallowed (always exits 0) so the editing session is never broken.
+- **Read** → `hooks/java_linter_reminder.py` reminds Claude to act on LSP diagnostics shown for the file.
 
 ## On-Demand Linting
 

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/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
 
-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.
+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 17 custom functional programming rules run, and they appear alongside IntelliJ's built-in inspections.
 
 ## Troubleshooting
 

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/editors/vscode/README.md

@@ -57,4 +57,4 @@ This extension **coexists** with the Red Hat Java extension (`redhat.java`) and
 
 ## Rules
 
-See the [main README](../../README.md) for the full list of 12 rules and configuration options via `.java-functional-lsp.json`.
+See the [main README](../../README.md) for the full list of 17 rules and configuration options via `.java-functional-lsp.json`.

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/editors/vscode/package-lock.json

@@ -194,20 +194,29 @@
       }
     },
     "node_modules/@azure/msal-node": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/@azure/msal-node/-/msal-node-5.1.2.tgz",
-      "integrity": "sha512-DoeSJ9U5KPAIZoHsPywvfEj2MhBniQe0+FSpjLUTdWoIkI999GB5USkW6nNEHnIaLVxROHXvprWA1KzdS1VQ4A==",
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/@azure/msal-node/-/msal-node-5.2.2.tgz",
+      "integrity": "sha512-toS+2AePxqyzb0YOKttDOOiSl3jrkK9aiqIvpurpis0O34QcIS5gToqrgT39p04Dpxw3YoUU0lxJKTpSFFfA6Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@azure/msal-common": "16.4.1",
-        "jsonwebtoken": "^9.0.0",
-        "uuid": "^8.3.0"
+        "@azure/msal-common": "16.6.2",
+        "jsonwebtoken": "^9.0.0"
       },
       "engines": {
         "node": ">=20"
       }
     },
+    "node_modules/@azure/msal-node/node_modules/@azure/msal-common": {
+      "version": "16.6.2",
+      "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-16.6.2.tgz",
+      "integrity": "sha512-hQjjsekAjB00cM1EmatWJlzhEoK2Qhz7Rj5gvM6tYf8iL7RM3tkxlpU9fG0+ofkulzg9AEEA6dIEnSmDr5ZqUA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
     "node_modules/@babel/code-frame": {
       "version": "7.29.0",
       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
@@ -4351,16 +4360,6 @@
       "license": "MIT",
       "optional": true
     },
-    "node_modules/uuid": {
-      "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/bin/uuid"
-      }
-    },
     "node_modules/validate-npm-package-license": {
       "version": "3.0.4",
       "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/hooks/hooks.json

@@ -15,13 +15,23 @@
     ],
     "PostToolUse": [
       {
-        "matcher": "Read|Edit|Write",
+        "matcher": "Read",
         "hooks": [
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/java_linter_reminder.py"
           }
         ]
+      },
+      {
+        "matcher": "Edit|MultiEdit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/post_tool_lint.py",
+            "timeout": 10
+          }
+        ]
       }
     ]
   }

java_functional_lsp-0.11.2/hooks/post_tool_lint.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""PostToolUse hook: lint a .java file after Edit/Write and surface violations to Claude.
+
+Reads the Claude Code PostToolUse JSON payload on stdin, runs java-functional-lsp
+on the edited file, and emits diagnostics as ``hookSpecificOutput.additionalContext``
+so the agent sees them in context and can fix them immediately (issue #70).
+
+Failure-safe by design: every path exits 0 — a linter problem must never break the
+editing session. Prefers the fast in-process import; falls back to the CLI when the
+package is not importable under this interpreter.
+"""
+
+from __future__ import annotations
+
+import json
+import signal
+import subprocess
+import sys
+from pathlib import Path
+
+TIMEOUT_SECONDS = 5  # hard cap; single-file analysis is typically <200ms
+MAX_DIAGNOSTICS = 25  # keep additionalContext bounded
+
+
+def _lint_in_process(path: Path) -> list[str] | None:
+    """Lint via direct import. Returns None if the package isn't importable here."""
+    try:
+        from java_functional_lsp.analyzers.base import is_excluded
+        from java_functional_lsp.cli import check_file, format_diagnostic, load_config
+    except ImportError:
+        return None
+    config = load_config(path)
+    if is_excluded(path.as_posix(), config.get("excludes", [])):
+        return []
+    return [format_diagnostic(path, d) for d in check_file(path, config)]
+
+
+def _lint_via_cli(path: Path) -> list[str]:
+    """Fallback: shell out to the installed CLI (exit 1 + stdout lines on violations)."""
+    proc = subprocess.run(
+        ["java-functional-lsp", "check", str(path)],
+        capture_output=True,
+        text=True,
+        timeout=TIMEOUT_SECONDS,
+        check=False,  # exit 1 just means violations were found
+    )
+    return [ln for ln in proc.stdout.splitlines() if ln.strip()]
+
+
+def main() -> None:
+    hook_input = json.load(sys.stdin)
+    file_path = (hook_input.get("tool_input") or {}).get("file_path", "")
+    if not file_path.endswith(".java"):
+        return  # silent no-op
+    path = Path(file_path)
+    if not path.is_file():
+        return  # tool call may have failed or the file was deleted
+
+    lines = _lint_in_process(path)
+    if lines is None:
+        lines = _lint_via_cli(path)
+    if not lines:
+        return  # clean file: stay silent, no per-edit context noise
+
+    if len(lines) > MAX_DIAGNOSTICS:
+        lines = [*lines[:MAX_DIAGNOSTICS], f"... and {len(lines) - MAX_DIAGNOSTICS} more"]
+    json.dump(
+        {
+            "hookSpecificOutput": {
+                "hookEventName": "PostToolUse",
+                "additionalContext": (
+                    "java-functional-lsp found violations in the file you just edited:\n"
+                    + "\n".join(lines)
+                    + "\nFix each violation now with your next Edit. Do not explain or list them."
+                ),
+            }
+        },
+        sys.stdout,
+    )
+
+
+if __name__ == "__main__":
+    if hasattr(signal, "SIGALRM"):  # POSIX hard runtime cap
+        signal.signal(signal.SIGALRM, lambda *_: sys.exit(0))
+        signal.alarm(TIMEOUT_SECONDS)
+    try:
+        main()
+    except Exception:
+        sys.exit(0)  # hooks must never break the session

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["hatchling==1.29.0"]
+requires = ["hatchling==1.30.1"]
 build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.11.0"
+version = "0.11.2"
 description = "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions"
 readme = "README.md"
 license = { text = "MIT" }

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/src/java_functional_lsp/__init__.py

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

{java_functional_lsp-0.11.0 → java_functional_lsp-0.11.2}/src/java_functional_lsp/analyzers/base.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import fnmatch
+import re
 from collections.abc import Generator
 from dataclasses import dataclass
 from enum import IntEnum
@@ -179,6 +180,73 @@ def references_var(node: Node, var_name: bytes) -> bool:
     return False
 
 
+def single_return_stmt(branch: Node | None) -> Node | None:
+    """Return the lone ``return_statement`` of a branch, or None.
+
+    Accepts a block (filters comments, requires exactly one statement) or a bare
+    statement. Shared by analyzers and fix generators that rewrite
+    ``if (...) return X;`` shapes.
+    """
+    if branch is None:
+        return None
+    if branch.type == "block":
+        stmts = [c for c in branch.named_children if c.type not in IGNORED_CHILDREN]
+    else:
+        stmts = [branch]
+    if len(stmts) != 1 or stmts[0].type != "return_statement":
+        return None
+    return stmts[0]
+
+
+def return_expr_node(return_stmt: Node) -> Node | None:
+    """Return the expression node of a ``return <expr>;`` statement, or None for a bare return."""
+    children = [c for c in return_stmt.named_children if c.type not in IGNORED_CHILDREN]
+    if not children:
+        return None
+    return children[0]
+
+
+def return_expr_text(return_stmt: Node) -> str | None:
+    """Return the expression text of a ``return <expr>;`` statement, or None for a bare return."""
+    expr = return_expr_node(return_stmt)
+    if expr is None or expr.text is None:
+        return None
+    decoded: str = expr.text.decode("utf-8")
+    return decoded
+
+
+def single_return_expr_text(branch: Node | None) -> str | None:
+    """Text of the expression in a branch that is exactly ``return <expr>;``, else None."""
+    stmt = single_return_stmt(branch)
+    if stmt is None:
+        return None
+    return return_expr_text(stmt)
+
+
+# Java identifiers may contain `$`, which regex `\b` treats as a non-word character:
+# `\b\$opt` never matches, and `\bopt` falsely matches inside `$opt`. These lookarounds
+# treat `$` as part of the identifier alphabet so both failure modes are excluded.
+_IDENT_BOUNDARY_START = r"(?<![\w$])"
+_IDENT_BOUNDARY_END = r"(?![\w$])"
+
+
+def rewrite_var_get_call(text: str, var_name: str, replacement: str) -> str | None:
+    """Rewrite ``var_name.get()`` calls in ``text`` to ``replacement``.
+
+    Tolerates whitespace around the ``.`` and parens (``opt .get ()`` is valid Java).
+    Returns None when nothing was rewritten — callers treat that as "this shape
+    can't be synthesised safely" and fall back to a placeholder or bail out.
+    """
+    pattern = re.compile(rf"{_IDENT_BOUNDARY_START}{re.escape(var_name)}\s*\.\s*get\s*\(\s*\)")
+    rewritten = pattern.sub(replacement, text)
+    return rewritten if rewritten != text else None
+
+
+def rewrite_var_references(text: str, var_name: str, replacement: str) -> str:
+    """Rewrite standalone references to ``var_name`` in ``text`` to ``replacement``."""
+    return re.sub(rf"{_IDENT_BOUNDARY_START}{re.escape(var_name)}{_IDENT_BOUNDARY_END}", replacement, text)
+
+
 def has_error_or_missing(node: Node) -> bool:
     """Return True if the subtree rooted at ``node`` contains any ERROR or MISSING nodes.