java-functional-lsp 0.1.0__py3-none-any.whl

java_functional_lsp/__init__.py

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

java_functional_lsp/analyzers/__init__.py

@@ -0,0 +1 @@
+"""DeeperDive Java code quality analyzers using tree-sitter."""

java_functional_lsp/analyzers/base.py

@@ -0,0 +1,112 @@
+"""Base analyzer class and diagnostic types."""
+
+from __future__ import annotations
+
+from collections.abc import Generator
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Any, Protocol
+
+import tree_sitter_java as tsjava
+from tree_sitter import Language, Node, Parser
+
+
+class Severity(IntEnum):
+    ERROR = 1
+    WARNING = 2
+    INFO = 3
+    HINT = 4
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    line: int  # 0-based
+    col: int
+    end_line: int
+    end_col: int
+    severity: Severity
+    code: str  # rule ID
+    message: str
+    source: str = "deeperdive-java-linter"
+
+
+class Analyzer(Protocol):
+    """Protocol for all analyzers."""
+
+    def analyze(self, tree: Any, source: bytes, config: dict[str, Any]) -> list[Diagnostic]:
+        """Analyze a parsed tree and return diagnostics."""
+        ...
+
+
+_parser: Parser | None = None
+_language: Language | None = None
+
+
+def get_parser() -> Parser:
+    """Get or create a reusable tree-sitter Java parser."""
+    global _parser, _language
+    if _parser is None:
+        _language = Language(tsjava.language())
+        _parser = Parser(_language)
+    return _parser
+
+
+def get_language() -> Language:
+    """Get the Java language for queries."""
+    global _language
+    if _language is None:
+        get_parser()
+    assert _language is not None
+    return _language
+
+
+def find_nodes(node: Node, type_name: str) -> Generator[Node, None, None]:
+    """Recursively find all descendant nodes of a given type."""
+    if node.type == type_name:
+        yield node
+    for child in node.children:
+        yield from find_nodes(child, type_name)
+
+
+def find_nodes_multi(node: Node, type_names: set[str]) -> Generator[Node, None, None]:
+    """Recursively find all descendant nodes matching any of the given types."""
+    if node.type in type_names:
+        yield node
+    for child in node.children:
+        yield from find_nodes_multi(child, type_names)
+
+
+def find_ancestor(node: Node, type_name: str) -> Node | None:
+    """Walk up the tree to find the nearest ancestor of a given type."""
+    parent = node.parent
+    while parent:
+        if parent.type == type_name:
+            return parent
+        parent = parent.parent
+    return None
+
+
+def has_ancestor(node: Node, type_names: set[str]) -> bool:
+    """Check if any ancestor matches one of the given types."""
+    parent = node.parent
+    while parent:
+        if parent.type in type_names:
+            return True
+        parent = parent.parent
+    return False
+
+
+def severity_from_config(config: dict[str, Any], rule_id: str, default: Severity = Severity.WARNING) -> Severity | None:
+    """Get severity for a rule from config. Returns None if rule is disabled."""
+    rules: dict[str, str] = config.get("rules", {})
+    level = rules.get(rule_id)
+    if level is None:
+        return default
+    if level == "off":
+        return None
+    return {
+        "error": Severity.ERROR,
+        "warning": Severity.WARNING,
+        "info": Severity.INFO,
+        "hint": Severity.HINT,
+    }.get(level, default)

java_functional_lsp/analyzers/exception_checker.py

@@ -0,0 +1,63 @@
+"""Exception handling rules: detect throw statements and catch-rethrow patterns."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .base import Diagnostic, find_nodes, severity_from_config
+
+_MESSAGES = {
+    "throw-statement": ("Avoid throwing exceptions. Use Either.left(error) or Try.of(() -> ...).toEither()."),
+    "catch-rethrow": (
+        "Avoid catching and rethrowing. Use Try.of(() -> ...).toEither() to convert exceptions to values."
+    ),
+}
+
+
+class ExceptionChecker:
+    """Detects throw statements and catch-rethrow anti-patterns."""
+
+    def analyze(self, tree: Any, source: bytes, config: dict[str, Any]) -> list[Diagnostic]:
+        diagnostics: list[Diagnostic] = []
+
+        # Rule: throw-statement
+        severity = severity_from_config(config, "throw-statement")
+        if severity is not None:
+            for node in find_nodes(tree.root_node, "throw_statement"):
+                diagnostics.append(
+                    Diagnostic(
+                        line=node.start_point[0],
+                        col=node.start_point[1],
+                        end_line=node.end_point[0],
+                        end_col=node.end_point[1],
+                        severity=severity,
+                        code="throw-statement",
+                        message=_MESSAGES["throw-statement"],
+                    )
+                )
+
+        # Rule: catch-rethrow
+        severity = severity_from_config(config, "catch-rethrow")
+        if severity is not None:
+            for node in find_nodes(tree.root_node, "catch_clause"):
+                body = node.child_by_field_name("body")
+                if body is None:
+                    continue
+                # Check if the block has exactly one statement and it's a throw
+                statements = [
+                    c for c in body.children if c.type not in ("{", "}", "comment", "line_comment", "block_comment")
+                ]
+                if len(statements) == 1 and statements[0].type == "throw_statement":
+                    diagnostics.append(
+                        Diagnostic(
+                            line=node.start_point[0],
+                            col=node.start_point[1],
+                            end_line=node.end_point[0],
+                            end_col=node.end_point[1],
+                            severity=severity,
+                            code="catch-rethrow",
+                            message=_MESSAGES["catch-rethrow"],
+                        )
+                    )
+
+        return diagnostics

java_functional_lsp/analyzers/mutation_checker.py

@@ -0,0 +1,152 @@
+"""Mutation and imperative pattern rules: detect mutable variables, loops, and imperative unwrapping."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .base import Diagnostic, find_nodes, find_nodes_multi, has_ancestor, severity_from_config
+
+_MESSAGES = {
+    "mutable-variable": "Avoid reassigning variables. Use final + functional transforms (map, flatMap, fold).",
+    "imperative-loop": "Replace imperative loop with .map(), .filter(), .flatMap(), or .foldLeft().",
+    "mutable-dto": "Use @Value instead of @Data/@Setter for immutable DTOs.",
+    "imperative-option-unwrap": "Avoid imperative unwrapping (isDefined/get). Use map(), flatMap(), or fold().",
+}
+
+_LOOP_TYPES = {"enhanced_for_statement", "for_statement", "while_statement"}
+_METHOD_TYPES = {"method_declaration", "constructor_declaration", "lambda_expression"}
+_CHECK_METHODS = {b"isDefined", b"isEmpty", b"isPresent", b"isNone"}
+
+
+class MutationChecker:
+    """Detects mutable variables, imperative loops, and imperative unwrapping patterns."""
+
+    def analyze(self, tree: Any, source: bytes, config: dict[str, Any]) -> list[Diagnostic]:
+        diagnostics: list[Diagnostic] = []
+
+        self._check_mutable_dto(tree, diagnostics, config)
+        self._check_imperative_loops(tree, diagnostics, config)
+        self._check_imperative_option_unwrap(tree, diagnostics, config)
+        self._check_mutable_variables(tree, diagnostics, config)
+
+        return diagnostics
+
+    def _check_mutable_dto(self, tree: Any, diagnostics: list[Diagnostic], config: dict[str, Any]) -> None:
+        """Detect @Data or @Setter annotations on classes."""
+        severity = severity_from_config(config, "mutable-dto")
+        if severity is None:
+            return
+
+        for node in find_nodes(tree.root_node, "marker_annotation"):
+            name_node = node.child_by_field_name("name")
+            if name_node is None:
+                continue
+            ann_text = name_node.text
+            if ann_text in (b"Data", b"Setter"):
+                # Verify it's on a class declaration
+                if node.parent and node.parent.type == "modifiers":
+                    grandparent = node.parent.parent
+                    if grandparent and grandparent.type == "class_declaration":
+                        diagnostics.append(
+                            Diagnostic(
+                                line=name_node.start_point[0],
+                                col=name_node.start_point[1],
+                                end_line=name_node.end_point[0],
+                                end_col=name_node.end_point[1],
+                                severity=severity,
+                                code="mutable-dto",
+                                message=_MESSAGES["mutable-dto"],
+                            )
+                        )
+
+    def _check_imperative_loops(self, tree: Any, diagnostics: list[Diagnostic], config: dict[str, Any]) -> None:
+        """Detect for/while loops that could be functional operations."""
+        severity = severity_from_config(config, "imperative-loop")
+        if severity is None:
+            return
+
+        for node in find_nodes_multi(tree.root_node, _LOOP_TYPES):
+            # Skip loops inside main methods
+            parent = node.parent
+            while parent:
+                if parent.type == "method_declaration":
+                    method_name_node = parent.child_by_field_name("name")
+                    if method_name_node and method_name_node.text == b"main":
+                        break
+                parent = parent.parent
+            else:
+                # Highlight just the keyword (for/while)
+                keyword = node.type.split("_")[0]  # "for" or "while" or "enhanced"
+                if keyword == "enhanced":
+                    keyword = "for"
+                diagnostics.append(
+                    Diagnostic(
+                        line=node.start_point[0],
+                        col=node.start_point[1],
+                        end_line=node.start_point[0],
+                        end_col=node.start_point[1] + len(keyword),
+                        severity=severity,
+                        code="imperative-loop",
+                        message=_MESSAGES["imperative-loop"],
+                    )
+                )
+
+    def _check_imperative_option_unwrap(self, tree: Any, diagnostics: list[Diagnostic], config: dict[str, Any]) -> None:
+        """Detect if(opt.isDefined()) { opt.get() } patterns."""
+        severity = severity_from_config(config, "imperative-option-unwrap")
+        if severity is None:
+            return
+
+        for if_node in find_nodes(tree.root_node, "if_statement"):
+            condition = if_node.child_by_field_name("condition")
+            if condition is None:
+                continue
+
+            # Look for method_invocation in condition
+            for invocation in find_nodes(condition, "method_invocation"):
+                name_node = invocation.child_by_field_name("name")
+                obj_node = invocation.child_by_field_name("object")
+                if name_node is None or obj_node is None:
+                    continue
+                if name_node.text not in _CHECK_METHODS:
+                    continue
+
+                # Check if the body contains .get() on the same object
+                obj_name = obj_node.text
+                body_text = if_node.text
+                if obj_name is not None and body_text is not None and obj_name + b".get()" in body_text:
+                    diagnostics.append(
+                        Diagnostic(
+                            line=if_node.start_point[0],
+                            col=if_node.start_point[1],
+                            end_line=if_node.end_point[0],
+                            end_col=if_node.end_point[1],
+                            severity=severity,
+                            code="imperative-option-unwrap",
+                            message=_MESSAGES["imperative-option-unwrap"],
+                        )
+                    )
+                break  # Only check first invocation in condition
+
+    def _check_mutable_variables(self, tree: Any, diagnostics: list[Diagnostic], config: dict[str, Any]) -> None:
+        """Detect local variables that are reassigned (non-final, mutated)."""
+        severity = severity_from_config(config, "mutable-variable")
+        if severity is None:
+            return
+
+        for node in find_nodes(tree.root_node, "assignment_expression"):
+            # Only flag reassignments inside method bodies
+            if not has_ancestor(node, _METHOD_TYPES):
+                continue
+
+            diagnostics.append(
+                Diagnostic(
+                    line=node.start_point[0],
+                    col=node.start_point[1],
+                    end_line=node.end_point[0],
+                    end_col=node.end_point[1],
+                    severity=severity,
+                    code="mutable-variable",
+                    message=_MESSAGES["mutable-variable"],
+                )
+            )

java_functional_lsp/analyzers/null_checker.py

@@ -0,0 +1,70 @@
+"""Null safety rules: detect null literals in arguments, returns, and assignments."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .base import Diagnostic, find_nodes, severity_from_config
+
+_MESSAGES = {
+    "null-literal-arg": "Avoid passing null as argument. Use Option.none(), a default value, or overload the method.",
+    "null-return": "Avoid returning null. Use Option.of(), Option.none(), or Either<Error, T>.",
+    "null-assignment": "Avoid assigning null to local variables. Use Option<T> to represent absence.",
+    "null-field-assignment": "Avoid null field initializers. Use Option<T> with Option.none() for optional fields.",
+}
+
+
+class NullChecker:
+    """Detects null literal usage in arguments, returns, and assignments."""
+
+    def analyze(self, tree: Any, source: bytes, config: dict[str, Any]) -> list[Diagnostic]:
+        diagnostics: list[Diagnostic] = []
+
+        for node in find_nodes(tree.root_node, "null_literal"):
+            parent = node.parent
+            if parent is None:
+                continue
+
+            rule_id = self._classify_null(node, parent)
+            if rule_id is None:
+                continue
+
+            severity = severity_from_config(config, rule_id)
+            if severity is None:
+                continue
+
+            diagnostics.append(
+                Diagnostic(
+                    line=node.start_point[0],
+                    col=node.start_point[1],
+                    end_line=node.end_point[0],
+                    end_col=node.end_point[1],
+                    severity=severity,
+                    code=rule_id,
+                    message=_MESSAGES[rule_id],
+                )
+            )
+
+        return diagnostics
+
+    def _classify_null(self, node: Any, parent: Any) -> str | None:
+        """Classify a null_literal by its context."""
+        # null in argument list -> null-literal-arg
+        if parent.type == "argument_list":
+            return "null-literal-arg"
+
+        # return null -> null-return
+        if parent.type == "return_statement":
+            return "null-return"
+
+        # variable_declarator with null value
+        if parent.type == "variable_declarator":
+            grandparent = parent.parent
+            if grandparent is None:
+                return None
+            if grandparent.type == "local_variable_declaration":
+                return "null-assignment"
+            if grandparent.type == "field_declaration":
+                return "null-field-assignment"
+
+        return None

java_functional_lsp/analyzers/spring_checker.py

@@ -0,0 +1,84 @@
+"""Spring configuration rules: detect field injection and component annotations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .base import Diagnostic, find_nodes, severity_from_config
+
+_MESSAGES = {
+    "field-injection": "Avoid @Autowired field injection. Use constructor injection with @Value (Lombok) classes.",
+    "component-annotation": "Avoid @Component/@Service/@Repository. Use @Configuration + @Bean instead.",
+}
+
+_BAD_ANNOTATIONS = {b"Component", b"Service", b"Repository"}
+
+
+class SpringChecker:
+    """Detects Spring anti-patterns: field injection and component scanning annotations."""
+
+    def analyze(self, tree: Any, source: bytes, config: dict[str, Any]) -> list[Diagnostic]:
+        diagnostics: list[Diagnostic] = []
+
+        self._check_field_injection(tree, diagnostics, config)
+        self._check_component_annotation(tree, diagnostics, config)
+
+        return diagnostics
+
+    def _check_field_injection(self, tree: Any, diagnostics: list[Diagnostic], config: dict[str, Any]) -> None:
+        """Detect @Autowired on field declarations."""
+        severity = severity_from_config(config, "field-injection")
+        if severity is None:
+            return
+
+        for node in find_nodes(tree.root_node, "marker_annotation"):
+            name_node = node.child_by_field_name("name")
+            if name_node is None or name_node.text != b"Autowired":
+                continue
+            # Check it's on a field declaration
+            if (
+                node.parent
+                and node.parent.type == "modifiers"
+                and node.parent.parent
+                and node.parent.parent.type == "field_declaration"
+            ):
+                diagnostics.append(
+                    Diagnostic(
+                        line=name_node.start_point[0],
+                        col=name_node.start_point[1],
+                        end_line=name_node.end_point[0],
+                        end_col=name_node.end_point[1],
+                        severity=severity,
+                        code="field-injection",
+                        message=_MESSAGES["field-injection"],
+                    )
+                )
+
+    def _check_component_annotation(self, tree: Any, diagnostics: list[Diagnostic], config: dict[str, Any]) -> None:
+        """Detect @Component, @Service, @Repository on classes."""
+        severity = severity_from_config(config, "component-annotation")
+        if severity is None:
+            return
+
+        for node in find_nodes(tree.root_node, "marker_annotation"):
+            name_node = node.child_by_field_name("name")
+            if name_node is None or name_node.text not in _BAD_ANNOTATIONS:
+                continue
+            # Check it's on a class declaration
+            if (
+                node.parent
+                and node.parent.type == "modifiers"
+                and node.parent.parent
+                and node.parent.parent.type == "class_declaration"
+            ):
+                diagnostics.append(
+                    Diagnostic(
+                        line=name_node.start_point[0],
+                        col=name_node.start_point[1],
+                        end_line=name_node.end_point[0],
+                        end_col=name_node.end_point[1],
+                        severity=severity,
+                        code="component-annotation",
+                        message=_MESSAGES["component-annotation"],
+                    )
+                )

java_functional_lsp/server.py

@@ -0,0 +1,145 @@
+"""Main LSP server for java-functional-lsp.
+
+Provides custom Java diagnostics via tree-sitter analysis.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+from urllib.parse import unquote, urlparse
+
+from lsprotocol import types as lsp
+from pygls.lsp.server import LanguageServer
+
+from .analyzers.base import Analyzer, Severity, get_parser
+from .analyzers.base import Diagnostic as LintDiagnostic
+from .analyzers.exception_checker import ExceptionChecker
+from .analyzers.mutation_checker import MutationChecker
+from .analyzers.null_checker import NullChecker
+from .analyzers.spring_checker import SpringChecker
+
+logger = logging.getLogger(__name__)
+
+_SEVERITY_MAP = {
+    Severity.ERROR: lsp.DiagnosticSeverity.Error,
+    Severity.WARNING: lsp.DiagnosticSeverity.Warning,
+    Severity.INFO: lsp.DiagnosticSeverity.Information,
+    Severity.HINT: lsp.DiagnosticSeverity.Hint,
+}
+
+_ANALYZERS: list[Analyzer] = [NullChecker(), ExceptionChecker(), MutationChecker(), SpringChecker()]
+
+
+class JavaFunctionalLspServer(LanguageServer):
+    def __init__(self) -> None:
+        super().__init__("java-functional-lsp", "0.1.0")
+        self._parser = get_parser()
+        self._config: dict[str, Any] = {}
+
+
+server = JavaFunctionalLspServer()
+
+
+def _uri_to_path(uri: str) -> str:
+    """Convert a file:// URI to a filesystem path."""
+    parsed = urlparse(uri)
+    return unquote(parsed.path)
+
+
+def _load_config(workspace_root: str | None) -> dict[str, Any]:
+    """Load .deeperdive-linter.json from workspace root if it exists."""
+    if not workspace_root:
+        return {}
+    config_path = Path(workspace_root) / ".deeperdive-linter.json"
+    if config_path.exists():
+        try:
+            result: dict[str, Any] = json.loads(config_path.read_text())
+            return result
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning("Failed to load config from %s: %s", config_path, e)
+    return {}
+
+
+def _to_lsp_diagnostic(diag: LintDiagnostic) -> lsp.Diagnostic:
+    """Convert an internal diagnostic to an LSP diagnostic."""
+    return lsp.Diagnostic(
+        range=lsp.Range(
+            start=lsp.Position(line=diag.line, character=diag.col),
+            end=lsp.Position(line=diag.end_line, character=diag.end_col),
+        ),
+        severity=_SEVERITY_MAP.get(diag.severity, lsp.DiagnosticSeverity.Warning),
+        code=diag.code,
+        source=diag.source,
+        message=diag.message,
+    )
+
+
+def _analyze_document(source_text: str) -> list[lsp.Diagnostic]:
+    """Run all analyzers on the given source text."""
+    source_bytes = source_text.encode("utf-8")
+    tree = server._parser.parse(source_bytes)
+    config = server._config
+
+    all_diagnostics = []
+    for analyzer in _ANALYZERS:
+        try:
+            diags = analyzer.analyze(tree, source_bytes, config)
+            all_diagnostics.extend(diags)
+        except Exception as e:
+            logger.error("Analyzer %s failed: %s", type(analyzer).__name__, e)
+
+    return [_to_lsp_diagnostic(d) for d in all_diagnostics]
+
+
+def _publish_diagnostics(uri: str) -> None:
+    """Analyze a document and publish diagnostics."""
+    doc = server.workspace.get_text_document(uri)
+    diagnostics = _analyze_document(doc.source)
+    server.text_document_publish_diagnostics(lsp.PublishDiagnosticsParams(uri=uri, diagnostics=diagnostics))
+
+
+@server.feature(lsp.INITIALIZED)
+def on_initialized(params: lsp.InitializedParams) -> None:
+    """Load config after initialization."""
+    root = None
+    if server.workspace.root_uri:
+        root = _uri_to_path(server.workspace.root_uri)
+    elif server.workspace.root_path:
+        root = server.workspace.root_path
+    server._config = _load_config(root)
+    logger.info(
+        "java-functional-lsp initialized (workspace: %s, rules: %s)",
+        root,
+        list(server._config.get("rules", {}).keys()) or "all defaults",
+    )
+
+
+@server.feature(lsp.TEXT_DOCUMENT_DID_OPEN)
+def on_did_open(params: lsp.DidOpenTextDocumentParams) -> None:
+    """Analyze document when opened."""
+    _publish_diagnostics(params.text_document.uri)
+
+
+@server.feature(lsp.TEXT_DOCUMENT_DID_CHANGE)
+def on_did_change(params: lsp.DidChangeTextDocumentParams) -> None:
+    """Re-analyze document on change."""
+    _publish_diagnostics(params.text_document.uri)
+
+
+@server.feature(lsp.TEXT_DOCUMENT_DID_SAVE)
+def on_did_save(params: lsp.DidSaveTextDocumentParams) -> None:
+    """Re-analyze document on save."""
+    _publish_diagnostics(params.text_document.uri)
+
+
+def main() -> None:
+    """Entry point for the LSP server."""
+    logging.basicConfig(level=logging.INFO, format="%(name)s %(levelname)s: %(message)s")
+    server.start_io()
+
+
+if __name__ == "__main__":
+    main()

java_functional_lsp-0.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: java-functional-lsp
+Version: 0.1.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
+Project-URL: Bug Tracker, https://github.com/aviadshiber/java-functional-lsp/issues
+Project-URL: Changelog, https://github.com/aviadshiber/java-functional-lsp/releases
+Author: Aviad S.
+License: MIT
+License-File: LICENSE
+Keywords: functional-programming,java,linter,lombok,lsp,tree-sitter,vavr
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: pygls>=1.3.0
+Requires-Dist: tree-sitter-java>=0.23.0
+Requires-Dist: tree-sitter>=0.23.0
+Description-Content-Type: text/markdown
+
+# java-functional-lsp
+
+[![CI](https://github.com/aviadshiber/java-functional-lsp/actions/workflows/test.yml/badge.svg)](https://github.com/aviadshiber/java-functional-lsp/actions/workflows/test.yml)
+[![PyPI version](https://img.shields.io/pypi/v/java-functional-lsp)](https://pypi.org/project/java-functional-lsp/)
+[![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp)](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.
+
+## 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` |
+
+## Install
+
+```bash
+pip install java-functional-lsp
+```
+
+Or from source:
+
+```bash
+pip install git+https://github.com/aviadshiber/java-functional-lsp.git
+```
+
+## Usage with Claude Code
+
+Install the `deeperdive-java-linter` plugin from the DeeperDive marketplace, which registers this server as a Java LSP.
+
+Or manually add to your Claude Code config:
+
+```json
+{
+  "lspServers": {
+    "java-functional": {
+      "command": "java-functional-lsp",
+      "extensionToLanguage": { ".java": "java" }
+    }
+  }
+}
+```
+
+## Configuration
+
+Create `.deeperdive-linter.json` in your project root to customize rules:
+
+```json
+{
+  "rules": {
+    "null-literal-arg": "warning",
+    "throw-statement": "info",
+    "imperative-loop": "hint",
+    "mutable-dto": "off"
+  }
+}
+```
+
+Severity levels: `error`, `warning`, `info`, `hint`, `off`.
+All rules default to `warning` when not configured.
+
+## 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 speaks the Language Server Protocol (LSP) via stdio, making it compatible with any LSP client.
+
+## Development
+
+```bash
+# Clone and setup
+git clone https://github.com/aviadshiber/java-functional-lsp.git
+cd java-functional-lsp
+uv sync
+
+# Run checks
+uv run ruff check src/ tests/
+uv run ruff format --check src/ tests/
+uv run mypy src/
+uv run pytest
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for full guidelines.
+
+## License
+
+MIT

java_functional_lsp-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+java_functional_lsp/__init__.py,sha256=jAgfWgoUHOCUykj2m4Fw-RX-dsZIdpD4z6N_3Ez-Pso,117
+java_functional_lsp/server.py,sha256=KIenYC_pXmASJQGbVsmONJb9MF-nb1_QBkvrkXW2KQM,4754
+java_functional_lsp/analyzers/__init__.py,sha256=m1Iba7lX5ayNIEfolEqkUF4s_8vVyzif33gzn7pT__k,64
+java_functional_lsp/analyzers/base.py,sha256=sZEn53NV1Igb7vm2V7r6ShCCADKanb1WX_QaGinE3OQ,3046
+java_functional_lsp/analyzers/exception_checker.py,sha256=B8NgSTGiaA3X2gl4lx4S_nJjsuCzeMVCikl2PPzirmY,2548
+java_functional_lsp/analyzers/mutation_checker.py,sha256=7_NwNreqU1NxwIh9eLgoo6sLp2QNKbmDyOFDY-RqpUY,7048
+java_functional_lsp/analyzers/null_checker.py,sha256=YrVoBJP1-ZE2d7vt_tMX4iNUHfEUQrTzXxj_47whuzQ,2517
+java_functional_lsp/analyzers/spring_checker.py,sha256=Asx81JeU7atBibtYw0otGivzki12SiTgGhoZM4f-gh8,3465
+java_functional_lsp-0.1.0.dist-info/METADATA,sha256=MswI80b-wJ4qi1NLCf2s-mYiBOkTTzQC3taXuX98E30,4610
+java_functional_lsp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+java_functional_lsp-0.1.0.dist-info/entry_points.txt,sha256=WYL5uaImAwrV6k8z2y9erzfA1h8KSEhWN0wjwUkECVU,72
+java_functional_lsp-0.1.0.dist-info/licenses/LICENSE,sha256=TKmXIfxUBfKDiWOTULE7TEZDQ5pNynIZJSRr3rqF3OE,1065
+java_functional_lsp-0.1.0.dist-info/RECORD,,

java_functional_lsp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

java_functional_lsp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+java-functional-lsp = java_functional_lsp.server:main

java_functional_lsp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aviad S.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.