java-functional-lsp 0.4.2__tar.gz → 0.6.0__tar.gz

{java_functional_lsp-0.4.2 → java_functional_lsp-0.6.0}/.github/workflows/vscode-ext.yml

@@ -21,7 +21,7 @@ jobs:
       - uses: actions/checkout@v6
 
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: "20"
 
@@ -35,7 +35,7 @@ jobs:
         run: npx vsce package
 
       - name: Upload VSIX artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: java-functional-lsp-vsix
           path: editors/vscode/*.vsix

{java_functional_lsp-0.4.2 → java_functional_lsp-0.6.0}/CONTRIBUTING.md

@@ -45,8 +45,11 @@ uv run pytest
 1. Choose the appropriate analyzer in `src/java_functional_lsp/analyzers/`
 2. Add the detection logic using tree-sitter node walking (see `base.py` helpers)
 3. Add the rule ID and message to the module's `_MESSAGES` dict
-4. Add tests in `tests/test_<analyzer>.py`
-5. Update the rules table in `README.md`
+4. Add a `DiagnosticData` entry to the module's `_DATA` dict with `fix_type`, `target_library`, and `rationale`
+5. Pass `data=_DATA["rule-id"]` when creating the `Diagnostic`
+6. Add tests in `tests/test_<analyzer>.py` (including a test verifying the `data` field)
+7. Optionally add a quick fix generator in `src/java_functional_lsp/fixes.py` and register it in `_FIX_REGISTRY`
+8. Update the rules table in `README.md`
 
 ## Reporting Issues
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.4.2
+Version: 0.6.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
@@ -33,24 +33,46 @@ Description-Content-Type: text/markdown
 [![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A Java Language Server that enforces functional programming best practices. Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
+A Java Language Server that provides two 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. **15 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.
 
 ## What it checks
 
-| Rule | Detects | Suggests |
-|------|---------|----------|
-| `null-literal-arg` | `null` passed as method argument | `Option.none()` or default value |
-| `null-return` | `return null` | `Option.of()`, `Option.none()`, or `Either` |
-| `null-assignment` | `Type x = null` | `Option<Type>` |
-| `null-field-assignment` | Field initialized to `null` | `Option<T>` with `Option.none()` |
-| `throw-statement` | `throw new XxxException(...)` | `Either.left()` or `Try.of()` |
-| `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()` |
-| `field-injection` | `@Autowired` on field | Constructor injection |
-| `component-annotation` | `@Component`/`@Service`/`@Repository` | `@Configuration` + `@Bean` |
+### Java language (via jdtls)
+
+When [jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) is installed, the server proxies all standard Java language features:
+
+- Compile errors and warnings
+- Missing imports and unresolved symbols
+- Type mismatches
+- Completions, hover, go-to-definition, find references
+
+Install jdtls separately: `brew install jdtls` (requires JDK 21+). Without jdtls, the server runs in standalone mode — the 12 custom rules still work, but you won't get compile errors or completions.
+
+### Functional programming rules
+
+| Rule | Detects | Suggests | Quick Fix |
+|------|---------|----------|-----------|
+| `null-literal-arg` | `null` passed as method argument | `Option.none()` or default value | — |
+| `null-return` | `return null` | `Option.of()`, `Option.none()`, or `Either` | ✅ |
+| `null-assignment` | `Type x = null` | `Option<Type>` | — |
+| `null-field-assignment` | Field initialized to `null` | `Option<T>` with `Option.none()` | — |
+| `throw-statement` | `throw new XxxException(...)` | `Either.left()` or `Try.of()` | — |
+| `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()` | — |
+| `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(...)` | ✅ |
+| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` | — |
 
 ## Install
 
@@ -64,7 +86,7 @@ pip install java-functional-lsp
 # From source
 pip install git+https://github.com/aviadshiber/java-functional-lsp.git
 
-# Optional: install jdtls for full Java language support (completions, hover, go-to-def)
+# Optional: install jdtls for full Java language support (see above)
 brew install jdtls
 ```
 
@@ -212,9 +234,76 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 - `throw-statement` and `catch-rethrow` are automatically suppressed inside `@Bean` methods
 - `mutable-dto` suggests `@ConstructorBinding` instead of `@Value` when the class has `@ConfigurationProperties`
 
+**Inline suppression** with `@SuppressWarnings`:
+
+```java
+// Suppress a specific rule on a method
+@SuppressWarnings("java-functional-lsp:null-return")
+public String findUser() { return null; }  // no diagnostic
+
+// Suppress multiple rules
+@SuppressWarnings({"java-functional-lsp:null-return", "java-functional-lsp:throw-statement"})
+public String findUser() { ... }
+
+// Suppress all java-functional-lsp rules
+@SuppressWarnings("java-functional-lsp")
+public String legacyMethod() { ... }
+```
+
+Works on classes, methods, constructors, fields, and local variables. Suppression applies to the annotated scope — a class-level annotation suppresses all methods within it.
+
+## Code actions (quick fixes)
+
+The server provides LSP code actions (`textDocument/codeAction`) that automatically refactor code. When your editor shows a diagnostic with a lightbulb icon, clicking it applies the fix:
+
+| Rule | Code Action | What it does |
+|------|-------------|--------------|
+| `frozen-mutation` | Switch to Vavr Immutable Collection | Rewrites `List.of()` → `io.vavr.collection.List.of()`, `.add(x)` → `= list.append(x)`, adds import |
+| `null-check-to-monadic` | Convert to Option monadic flow | Rewrites `if (x != null) { return x.foo(); }` → `Option.of(x).map(...).getOrNull()`, adds import |
+| `null-return` | Replace with Option.none() | Rewrites `return null` → `return Option.none()`, adds import |
+
+Quick fixes automatically add the required Vavr import if it's not already present. Disable auto-import with `"autoImportVavr": false` in config.
+
+## Agent mode (AI integration)
+
+Every diagnostic includes a machine-readable `data` payload designed for AI agents like Claude Code:
+
+```json
+{
+  "code": "frozen-mutation",
+  "message": "Runtime Exception Risk: Mutating a frozen structure...",
+  "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."
+  }
+}
+```
+
+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*.
+
+**Agent mode configuration** in `.java-functional-lsp.json`:
+
+```json
+{
+  "autoImportVavr": true,
+  "strictPurity": true
+}
+```
+
+| Key | Default | Effect |
+|-----|---------|--------|
+| `autoImportVavr` | `true` | Quick fixes auto-add Vavr/Option imports |
+| `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.
+
 ## How it works
 
-Uses [tree-sitter](https://tree-sitter.github.io/) with the Java grammar for fast, incremental AST parsing. No Java compiler or classpath needed — analysis runs on raw source files.
+The server has two layers:
+
+- **Custom rules** — uses [tree-sitter](https://tree-sitter.github.io/) with the Java grammar for sub-millisecond AST analysis (~0.4ms per file). No compiler or classpath needed — runs on raw source files.
+- **Java language features** — proxies [Eclipse jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) for compile errors, completions, hover, go-to-definition, and references. Diagnostics from both layers are merged and published together.
 
 The server speaks the Language Server Protocol (LSP) via stdio, making it compatible with any LSP client.
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.6.0}/README.md

@@ -5,24 +5,46 @@
 [![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A Java Language Server that enforces functional programming best practices. Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
+A Java Language Server that provides two 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. **15 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.
 
 ## What it checks
 
-| Rule | Detects | Suggests |
-|------|---------|----------|
-| `null-literal-arg` | `null` passed as method argument | `Option.none()` or default value |
-| `null-return` | `return null` | `Option.of()`, `Option.none()`, or `Either` |
-| `null-assignment` | `Type x = null` | `Option<Type>` |
-| `null-field-assignment` | Field initialized to `null` | `Option<T>` with `Option.none()` |
-| `throw-statement` | `throw new XxxException(...)` | `Either.left()` or `Try.of()` |
-| `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()` |
-| `field-injection` | `@Autowired` on field | Constructor injection |
-| `component-annotation` | `@Component`/`@Service`/`@Repository` | `@Configuration` + `@Bean` |
+### Java language (via jdtls)
+
+When [jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) is installed, the server proxies all standard Java language features:
+
+- Compile errors and warnings
+- Missing imports and unresolved symbols
+- Type mismatches
+- Completions, hover, go-to-definition, find references
+
+Install jdtls separately: `brew install jdtls` (requires JDK 21+). Without jdtls, the server runs in standalone mode — the 12 custom rules still work, but you won't get compile errors or completions.
+
+### Functional programming rules
+
+| Rule | Detects | Suggests | Quick Fix |
+|------|---------|----------|-----------|
+| `null-literal-arg` | `null` passed as method argument | `Option.none()` or default value | — |
+| `null-return` | `return null` | `Option.of()`, `Option.none()`, or `Either` | ✅ |
+| `null-assignment` | `Type x = null` | `Option<Type>` | — |
+| `null-field-assignment` | Field initialized to `null` | `Option<T>` with `Option.none()` | — |
+| `throw-statement` | `throw new XxxException(...)` | `Either.left()` or `Try.of()` | — |
+| `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()` | — |
+| `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(...)` | ✅ |
+| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` | — |
 
 ## Install
 
@@ -36,7 +58,7 @@ pip install java-functional-lsp
 # From source
 pip install git+https://github.com/aviadshiber/java-functional-lsp.git
 
-# Optional: install jdtls for full Java language support (completions, hover, go-to-def)
+# Optional: install jdtls for full Java language support (see above)
 brew install jdtls
 ```
 
@@ -184,9 +206,76 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 - `throw-statement` and `catch-rethrow` are automatically suppressed inside `@Bean` methods
 - `mutable-dto` suggests `@ConstructorBinding` instead of `@Value` when the class has `@ConfigurationProperties`
 
+**Inline suppression** with `@SuppressWarnings`:
+
+```java
+// Suppress a specific rule on a method
+@SuppressWarnings("java-functional-lsp:null-return")
+public String findUser() { return null; }  // no diagnostic
+
+// Suppress multiple rules
+@SuppressWarnings({"java-functional-lsp:null-return", "java-functional-lsp:throw-statement"})
+public String findUser() { ... }
+
+// Suppress all java-functional-lsp rules
+@SuppressWarnings("java-functional-lsp")
+public String legacyMethod() { ... }
+```
+
+Works on classes, methods, constructors, fields, and local variables. Suppression applies to the annotated scope — a class-level annotation suppresses all methods within it.
+
+## Code actions (quick fixes)
+
+The server provides LSP code actions (`textDocument/codeAction`) that automatically refactor code. When your editor shows a diagnostic with a lightbulb icon, clicking it applies the fix:
+
+| Rule | Code Action | What it does |
+|------|-------------|--------------|
+| `frozen-mutation` | Switch to Vavr Immutable Collection | Rewrites `List.of()` → `io.vavr.collection.List.of()`, `.add(x)` → `= list.append(x)`, adds import |
+| `null-check-to-monadic` | Convert to Option monadic flow | Rewrites `if (x != null) { return x.foo(); }` → `Option.of(x).map(...).getOrNull()`, adds import |
+| `null-return` | Replace with Option.none() | Rewrites `return null` → `return Option.none()`, adds import |
+
+Quick fixes automatically add the required Vavr import if it's not already present. Disable auto-import with `"autoImportVavr": false` in config.
+
+## Agent mode (AI integration)
+
+Every diagnostic includes a machine-readable `data` payload designed for AI agents like Claude Code:
+
+```json
+{
+  "code": "frozen-mutation",
+  "message": "Runtime Exception Risk: Mutating a frozen structure...",
+  "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."
+  }
+}
+```
+
+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*.
+
+**Agent mode configuration** in `.java-functional-lsp.json`:
+
+```json
+{
+  "autoImportVavr": true,
+  "strictPurity": true
+}
+```
+
+| Key | Default | Effect |
+|-----|---------|--------|
+| `autoImportVavr` | `true` | Quick fixes auto-add Vavr/Option imports |
+| `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.
+
 ## How it works
 
-Uses [tree-sitter](https://tree-sitter.github.io/) with the Java grammar for fast, incremental AST parsing. No Java compiler or classpath needed — analysis runs on raw source files.
+The server has two layers:
+
+- **Custom rules** — uses [tree-sitter](https://tree-sitter.github.io/) with the Java grammar for sub-millisecond AST analysis (~0.4ms per file). No compiler or classpath needed — runs on raw source files.
+- **Java language features** — proxies [Eclipse jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) for compile errors, completions, hover, go-to-definition, and references. Diagnostics from both layers are merged and published together.
 
 The server speaks the Language Server Protocol (LSP) via stdio, making it compatible with any LSP client.
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.6.0}/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 12 functional programming rules enforcement. 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 15 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 12 functional programming rules. Gives you **full Java language support** (completions, hover, go-to-def, compile errors) **plus** custom diagnostics — all before compilation.
+A Java LSP server that wraps jdtls and adds 15 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,22 +22,47 @@ brew install jdtls
 
 Without jdtls, the server runs in standalone mode — custom rules still work, but no completions/hover/compile errors.
 
-## Rules (12 checks)
-
-| Rule | Detects | Suggests |
-|------|---------|----------|
-| `null-literal-arg` | `null` passed as argument | `Option.none()` or default |
-| `null-return` | `return null` | `Option.of()`, `Option.none()`, or `Either` |
-| `null-assignment` | `Type x = null` | `Option<Type>` |
-| `null-field-assignment` | Field initialized to `null` | `Option<T>` with `Option.none()` |
-| `throw-statement` | `throw new XxxException(...)` | `Either.left()` or `Try.of()` |
-| `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()` |
-| `field-injection` | `@Autowired` on field | Constructor injection |
-| `component-annotation` | `@Component`/`@Service`/`@Repository` | `@Configuration` + `@Bean` |
+## Rules (15 checks)
+
+| Rule | Detects | Suggests | Quick Fix |
+|------|---------|----------|-----------|
+| `null-literal-arg` | `null` passed as argument | `Option.none()` or default | — |
+| `null-return` | `return null` | `Option.of()`, `Option.none()`, or `Either` | ✅ |
+| `null-assignment` | `Type x = null` | `Option<Type>` | — |
+| `null-field-assignment` | Field initialized to `null` | `Option<T>` with `Option.none()` | — |
+| `throw-statement` | `throw new XxxException(...)` | `Either.left()` or `Try.of()` | — |
+| `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()` | — |
+| `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(...)` | ✅ |
+| `impure-method` | Method mixing pure logic with side-effects | Extract pure logic; wrap IO in `Try` | — |
+
+## Code Actions (Quick Fixes)
+
+Rules marked ✅ provide automated `textDocument/codeAction` fixes:
+
+- **frozen-mutation** → "Switch to Vavr Immutable Collection" — rewrites type, init, and mutation call to Vavr persistent API, adds import
+- **null-check-to-monadic** → "Convert to Option monadic flow" — rewrites `if (x != null)` to `Option.of(x).map(...)`, adds import
+- **null-return** → "Replace with Option.none()" — replaces `null` with `Option.none()`, adds import
+
+## Agent-Ready Diagnostics
+
+Every diagnostic includes a machine-readable `data` payload:
+
+```json
+{
+  "fixType": "REPLACE_WITH_VAVR_LIST",
+  "targetLibrary": "io.vavr.collection.List",
+  "rationale": "Runtime mutation of List.of() causes UnsupportedOperationException."
+}
+```
+
+This lets AI agents apply fixes with confidence — `fixType` says what to do, `targetLibrary` says which dependency, `rationale` says why.
 
 ## Configuration
 
@@ -50,14 +75,19 @@ Create `.java-functional-lsp.json` in your project root:
     "imperative-loop": "hint",
     "mutable-variable": "info",
     "throw-statement": "off"
-  }
+  },
+  "autoImportVavr": true,
+  "strictPurity": false
 }
 ```
 
 - `excludes` — glob patterns to skip files/directories entirely
 - `rules` — per-rule severity: `error`, `warning` (default), `info`, `hint`, `off`
+- `autoImportVavr` — quick fixes auto-add Vavr imports (default: `true`)
+- `strictPurity` — `impure-method` uses WARNING instead of HINT (default: `false`)
 - `throw-statement`/`catch-rethrow` auto-suppressed in `@Bean` methods
 - `mutable-dto` suggests `@ConstructorBinding` for `@ConfigurationProperties` classes
+- Inline suppression: `@SuppressWarnings("java-functional-lsp:rule-id")` on any declaration
 
 ## Automatic Enforcement
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.6.0}/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "java-functional-lsp",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "java-functional-lsp",
-      "version": "0.3.0",
+      "version": "0.4.1",
       "license": "MIT",
       "dependencies": {
         "vscode-languageclient": "^9.0.0"
@@ -1411,9 +1411,9 @@
       "license": "BSD-2-Clause"
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "version": "1.1.13",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+      "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2306,9 +2306,9 @@
       }
     },
     "node_modules/glob/node_modules/brace-expansion": {
-      "version": "5.0.4",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz",
-      "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==",
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
+      "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3401,9 +3401,9 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -4409,9 +4409,9 @@
       }
     },
     "node_modules/vscode-languageclient/node_modules/brace-expansion": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+      "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0"

{java_functional_lsp-0.4.2 → java_functional_lsp-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.4.2"
+version = "0.6.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.4.2 → java_functional_lsp-0.6.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.4.2"
+__version__ = "0.6.0"

{java_functional_lsp-0.4.2 → java_functional_lsp-0.6.0}/src/java_functional_lsp/analyzers/base.py

@@ -19,6 +19,15 @@ class Severity(IntEnum):
     HINT = 4
 
 
+@dataclass(frozen=True)
+class DiagnosticData:
+    """Machine-readable metadata for AI agents and automated refactoring."""
+
+    fix_type: str  # e.g. "REPLACE_WITH_VAVR_LIST", "WRAP_IN_OPTION"
+    target_library: str  # e.g. "io.vavr.collection.List"
+    rationale: str  # human+machine readable explanation
+
+
 @dataclass(frozen=True)
 class Diagnostic:
     line: int  # 0-based
@@ -29,6 +38,7 @@ class Diagnostic:
     code: str  # rule ID
     message: str
     source: str = "java-functional-lsp"
+    data: DiagnosticData | None = None
 
 
 class Analyzer(Protocol):
@@ -160,6 +170,89 @@ def is_excluded(path_str: str, patterns: list[str]) -> bool:
     return any(fnmatch.fnmatch(normalized, pattern) for pattern in patterns)
 
 
+_SUPPRESS_PREFIX = "java-functional-lsp"
+_DECLARATION_TYPES = frozenset(
+    {
+        "method_declaration",
+        "class_declaration",
+        "interface_declaration",
+        "enum_declaration",
+        "record_declaration",
+        "field_declaration",
+        "local_variable_declaration",
+        "constructor_declaration",
+    }
+)
+
+
+def is_suppressed(root: Node, line: int, col: int, rule_id: str) -> bool:
+    """Check if a diagnostic at (line, col) is suppressed by @SuppressWarnings."""
+    node = root.descendant_for_point_range((line, col), (line, col))
+    if node is None:
+        return False
+    current: Node | None = node
+    while current is not None:
+        if current.type in _DECLARATION_TYPES:
+            modifiers = next((c for c in current.children if c.type == "modifiers"), None)
+            if modifiers and _modifiers_suppress(modifiers, rule_id):
+                return True
+        current = current.parent
+    return False
+
+
+def _modifiers_suppress(modifiers: Node, rule_id: str) -> bool:
+    """Check if modifiers contain @SuppressWarnings suppressing the given rule."""
+    for child in modifiers.named_children:
+        if child.type == "annotation":
+            name_node = child.child_by_field_name("name")
+            if name_node and name_node.text == b"SuppressWarnings":
+                args = child.child_by_field_name("arguments")
+                if args and _annotation_args_suppress(args, rule_id):
+                    return True
+    return False
+
+
+def _annotation_args_suppress(args: Node, rule_id: str) -> bool:
+    """Parse @SuppressWarnings value(s) and check for rule match."""
+    for string_node in find_nodes(args, "string_literal"):
+        if string_node.text is None or len(string_node.text) < len('""'):
+            continue
+        value = string_node.text[1:-1].decode("utf-8")
+        if value == _SUPPRESS_PREFIX:
+            return True
+        if value == f"{_SUPPRESS_PREFIX}:{rule_id}":
+            return True
+    return False
+
+
+def extract_null_check_var(condition: Node) -> bytes | None:
+    """Extract the variable from a `x != null` or `null != x` binary condition.
+
+    Handles parenthesized expressions. Returns the variable name as bytes, or None.
+    """
+    node = condition
+    if node.type == "parenthesized_expression" and node.named_child_count == 1:
+        node = node.named_children[0]
+
+    if node.type != "binary_expression":
+        return None
+
+    # Must have != operator (tree-sitter stores operators as unnamed children)
+    if not any(c.type == "!=" for c in node.children):
+        return None
+
+    left = node.child_by_field_name("left")
+    right = node.child_by_field_name("right")
+    if left is None or right is None:
+        return None
+
+    var_node = left if right.type == "null_literal" else (right if left.type == "null_literal" else None)
+    if var_node is not None and var_node.type == "identifier":
+        val: bytes | None = var_node.text
+        return val
+    return None
+
+
 def has_sibling_annotation(modifiers_node: Node, annotation_name: bytes) -> bool:
     """Check if a modifiers node contains an annotation with the given name.