java-functional-lsp 0.1.0__tar.gz → 0.3.0__tar.gz

java_functional_lsp-0.3.0/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "java-functional-lsp",
+  "description": "Java LSP with functional programming rules enforcement — null safety, immutability, no exceptions, Spring best practices. Wraps jdtls for full Java language support.",
+  "version": "0.3.0"
+}

{java_functional_lsp-0.1.0 → java_functional_lsp-0.3.0}/.github/workflows/release-drafter.yml

@@ -3,17 +3,15 @@ name: Release Drafter
 on:
   push:
     branches: [main]
-  pull_request:
-    types: [opened, reopened, synchronize]
 
 permissions:
-  contents: read
+  contents: write
   pull-requests: write
 
 jobs:
   update-release-draft:
     runs-on: ubuntu-latest
     steps:
-      - uses: release-drafter/release-drafter@v6
+      - uses: release-drafter/release-drafter@v7
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

java_functional_lsp-0.3.0/.github/workflows/update-homebrew.yml

@@ -0,0 +1,61 @@
+name: Update Homebrew Formula
+
+on:
+  workflow_run:
+    workflows: ["Publish to PyPI"]
+    types: [completed]
+  workflow_dispatch:
+
+jobs:
+  update-formula:
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }}
+    steps:
+      - uses: actions/checkout@v6
+      - name: Get release version
+        id: version
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          VERSION=$(gh api "repos/${{ github.repository }}/releases/latest" --jq .tag_name)
+          echo "version=${VERSION#v}" >> "$GITHUB_OUTPUT"
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Wait for PyPI availability
+        env:
+          PKG_VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          for i in $(seq 1 30); do
+            if pip index versions java-functional-lsp 2>/dev/null | grep -q "$PKG_VERSION"; then
+              echo "java-functional-lsp==$PKG_VERSION available on PyPI"
+              break
+            fi
+            echo "Waiting for PyPI... attempt $i/30"
+            sleep 20
+          done
+      - name: Generate formula
+        env:
+          PKG_VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          python3 scripts/generate-formula.py "$PKG_VERSION" > java-functional-lsp.rb
+          echo "Generated formula:"
+          cat java-functional-lsp.rb
+      - name: Checkout tap repo
+        uses: actions/checkout@v6
+        with:
+          repository: aviadshiber/homebrew-tap
+          token: ${{ secrets.TAP_GITHUB_TOKEN }}
+          path: homebrew-tap
+      - name: Update formula
+        env:
+          PKG_VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          cp java-functional-lsp.rb homebrew-tap/Formula/java-functional-lsp.rb
+          cd homebrew-tap
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Formula/java-functional-lsp.rb
+          git diff --cached --quiet || git commit -m "Update java-functional-lsp to $PKG_VERSION"
+          git push

java_functional_lsp-0.3.0/.github/workflows/vscode-ext.yml

@@ -0,0 +1,48 @@
+name: VS Code Extension
+
+on:
+  push:
+    paths:
+      - "editors/vscode/**"
+    branches: [main]
+  release:
+    types: [published]
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: editors/vscode
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Compile
+        run: npm run compile
+
+      - name: Package VSIX
+        run: npx vsce package --no-dependencies
+
+      - name: Upload VSIX artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: java-functional-lsp-vsix
+          path: editors/vscode/*.vsix
+
+      - name: Attach VSIX to release
+        if: github.event_name == 'release'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+        run: gh release upload "$RELEASE_TAG" *.vsix

{java_functional_lsp-0.1.0 → java_functional_lsp-0.3.0}/.gitignore

@@ -14,5 +14,9 @@ htmlcov/
 .coverage
 *.egg
 *.zip
+# VS Code extension
+editors/vscode/node_modules/
+editors/vscode/out/
+*.vsix
 # Claude Code
 .claude/

{java_functional_lsp-0.1.0 → java_functional_lsp-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.1.0
+Version: 0.3.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
@@ -29,8 +29,8 @@ 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/)
+[![PyPI version](https://img.shields.io/pypi/v/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
+[![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.
@@ -55,18 +55,50 @@ A Java Language Server that enforces functional programming best practices. Desi
 ## Install
 
 ```bash
+# Homebrew
+brew install aviadshiber/tap/java-functional-lsp
+
+# pip
 pip install java-functional-lsp
+
+# From source
+pip install git+https://github.com/aviadshiber/java-functional-lsp.git
 ```
 
-Or from source:
+## IDE Setup
+
+### VS Code
+
+Install the extension from a `.vsix` file ([download from releases](https://github.com/aviadshiber/java-functional-lsp/releases)) or build it:
 
 ```bash
-pip install git+https://github.com/aviadshiber/java-functional-lsp.git
+cd editors/vscode
+npm install && npm run compile
+npx vsce package
+code --install-extension java-functional-lsp-*.vsix
 ```
 
-## Usage with Claude Code
+The extension launches the LSP server automatically for `.java` files. Configure the binary path in settings if needed (`javaFunctionalLsp.serverPath`). See [editors/vscode/README.md](editors/vscode/README.md) for details.
+
+### IntelliJ IDEA
+
+Use the [LSP4IJ](https://github.com/redhat-developer/lsp4ij) plugin (works on Community & Ultimate):
+
+1. Install **LSP4IJ** from the JetBrains Marketplace
+2. **Settings** → **Languages & Frameworks** → **Language Servers** → **`+`**
+3. Set **Command**: `java-functional-lsp`, then in **Mappings** → **File name patterns** add `*.java` with Language Id `java`
 
-Install the `deeperdive-java-linter` plugin from the DeeperDive marketplace, which registers this server as a Java LSP.
+See [editors/intellij/README.md](editors/intellij/README.md) for detailed instructions.
+
+### Claude Code
+
+Install as a plugin directly from GitHub:
+
+```bash
+claude plugin add https://github.com/aviadshiber/java-functional-lsp.git
+```
+
+This registers the LSP server, adds auto-install hooks, and provides the `/lint-java` command.
 
 Or manually add to your Claude Code config:
 
@@ -81,9 +113,19 @@ Or manually add to your Claude Code config:
 }
 ```
 
+### Other Editors
+
+Any LSP client that supports stdio transport can use this server. Point it to the `java-functional-lsp` command for `java` files.
+
+| Editor | Config |
+|--------|--------|
+| **Neovim** | `vim.lsp.start({ cmd = {"java-functional-lsp"}, filetypes = {"java"} })` |
+| **Emacs (eglot)** | `(add-to-list 'eglot-server-programs '(java-mode "java-functional-lsp"))` |
+| **Sublime Text** | LSP package → add server with `"command": ["java-functional-lsp"]` |
+
 ## Configuration
 
-Create `.deeperdive-linter.json` in your project root to customize rules:
+Create `.java-functional-lsp.json` in your project root to customize rules:
 
 ```json
 {

{java_functional_lsp-0.1.0 → java_functional_lsp-0.3.0}/README.md

@@ -1,8 +1,8 @@
 # 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/)
+[![PyPI version](https://img.shields.io/pypi/v/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
+[![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.
@@ -27,18 +27,50 @@ A Java Language Server that enforces functional programming best practices. Desi
 ## Install
 
 ```bash
+# Homebrew
+brew install aviadshiber/tap/java-functional-lsp
+
+# pip
 pip install java-functional-lsp
+
+# From source
+pip install git+https://github.com/aviadshiber/java-functional-lsp.git
 ```
 
-Or from source:
+## IDE Setup
+
+### VS Code
+
+Install the extension from a `.vsix` file ([download from releases](https://github.com/aviadshiber/java-functional-lsp/releases)) or build it:
 
 ```bash
-pip install git+https://github.com/aviadshiber/java-functional-lsp.git
+cd editors/vscode
+npm install && npm run compile
+npx vsce package
+code --install-extension java-functional-lsp-*.vsix
 ```
 
-## Usage with Claude Code
+The extension launches the LSP server automatically for `.java` files. Configure the binary path in settings if needed (`javaFunctionalLsp.serverPath`). See [editors/vscode/README.md](editors/vscode/README.md) for details.
+
+### IntelliJ IDEA
+
+Use the [LSP4IJ](https://github.com/redhat-developer/lsp4ij) plugin (works on Community & Ultimate):
+
+1. Install **LSP4IJ** from the JetBrains Marketplace
+2. **Settings** → **Languages & Frameworks** → **Language Servers** → **`+`**
+3. Set **Command**: `java-functional-lsp`, then in **Mappings** → **File name patterns** add `*.java` with Language Id `java`
 
-Install the `deeperdive-java-linter` plugin from the DeeperDive marketplace, which registers this server as a Java LSP.
+See [editors/intellij/README.md](editors/intellij/README.md) for detailed instructions.
+
+### Claude Code
+
+Install as a plugin directly from GitHub:
+
+```bash
+claude plugin add https://github.com/aviadshiber/java-functional-lsp.git
+```
+
+This registers the LSP server, adds auto-install hooks, and provides the `/lint-java` command.
 
 Or manually add to your Claude Code config:
 
@@ -53,9 +85,19 @@ Or manually add to your Claude Code config:
 }
 ```
 
+### Other Editors
+
+Any LSP client that supports stdio transport can use this server. Point it to the `java-functional-lsp` command for `java` files.
+
+| Editor | Config |
+|--------|--------|
+| **Neovim** | `vim.lsp.start({ cmd = {"java-functional-lsp"}, filetypes = {"java"} })` |
+| **Emacs (eglot)** | `(add-to-list 'eglot-server-programs '(java-mode "java-functional-lsp"))` |
+| **Sublime Text** | LSP package → add server with `"command": ["java-functional-lsp"]` |
+
 ## Configuration
 
-Create `.deeperdive-linter.json` in your project root to customize rules:
+Create `.java-functional-lsp.json` in your project root to customize rules:
 
 ```json
 {

java_functional_lsp-0.3.0/SKILL.md

@@ -0,0 +1,77 @@
+---
+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.
+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.
+
+## Prerequisites
+
+```bash
+# Install the LSP server
+brew install aviadshiber/tap/java-functional-lsp
+# Or: pip install java-functional-lsp
+
+# Install jdtls for full Java support (optional)
+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` |
+
+## Configuration
+
+Create `.java-functional-lsp.json` in your project root:
+
+```json
+{
+  "rules": {
+    "imperative-loop": "hint",
+    "mutable-variable": "info",
+    "throw-statement": "off"
+  }
+}
+```
+
+Severity levels: `error`, `warning` (default), `info`, `hint`, `off`.
+
+## On-Demand Linting
+
+Use `/lint-java <path>` to force-run the linter on specific files or directories.
+
+## Releasing a New Version
+
+To release a new version:
+
+1. Bump version in `src/java_functional_lsp/__init__.py` and `pyproject.toml`
+2. Update `.claude-plugin/plugin.json` version to match
+3. Commit and push to main
+4. Create a GitHub release with a tag matching `v*` (e.g., `v0.3.0`)
+5. CI automatically publishes to PyPI and builds the VS Code extension `.vsix`
+6. Run `python3 scripts/generate-formula.py <version>` and update the Homebrew tap
+
+## Troubleshooting
+
+- **"java-functional-lsp not found"**: Run `brew install aviadshiber/tap/java-functional-lsp`
+- **No completions/hover**: Install jdtls: `brew install jdtls`
+- **Too many warnings**: Create `.java-functional-lsp.json` to tune severity or disable noisy rules

java_functional_lsp-0.3.0/commands/lint-java.md

@@ -0,0 +1,40 @@
+---
+name: lint-java
+description: Run java-functional-lsp linter on Java files and report diagnostics
+allowed-tools: Bash, Read, Glob
+---
+
+# Java Functional Linter
+
+Run the Java code quality linter on specified files or directories.
+
+## Arguments
+
+$ARGUMENTS - Java files, directories, or glob patterns to lint. If empty, lint all .java files in the current directory.
+
+## Instructions
+
+1. Determine the target files:
+   - If $ARGUMENTS is provided, use it as the path(s)
+   - If empty, use the current working directory
+
+2. Run the linter:
+   ```bash
+   java-functional-lsp check $ARGUMENTS
+   ```
+   If no arguments: `java-functional-lsp check --dir .`
+
+3. Present the results clearly:
+   - Group diagnostics by file
+   - For each diagnostic, show the line number, rule, and suggestion
+   - If the file is short, show the offending line of code
+   - Summarize total issues at the end
+
+4. If the user asks to fix issues, suggest concrete code changes:
+   - `null-return` → wrap in `Option.of()` or return `Either.left(error)`
+   - `throw-statement` → convert to `Either.left()` or `Try.of()`
+   - `mutable-variable` → make final, use functional transforms
+   - `imperative-loop` → replace with `.map()`, `.filter()`, `.flatMap()`
+   - `mutable-dto` → change `@Data` to `@Value`
+   - `field-injection` → convert to constructor injection
+   - `component-annotation` → move to `@Configuration` class with `@Bean`

java_functional_lsp-0.3.0/editors/intellij/README.md

@@ -0,0 +1,90 @@
+# Java Functional LSP — IntelliJ IDEA Setup
+
+Use [LSP4IJ](https://github.com/redhat-developer/lsp4ij) (by Red Hat) to connect `java-functional-lsp` to IntelliJ IDEA. Works on both **Community** and **Ultimate** editions.
+
+## Prerequisites
+
+1. Install the LSP server:
+
+   ```bash
+   # Homebrew
+   brew install aviadshiber/tap/java-functional-lsp
+
+   # pip
+   pip install java-functional-lsp
+   ```
+
+2. Verify it's on your PATH:
+
+   ```bash
+   java-functional-lsp --help
+   ```
+
+   If not on PATH, note the full path (e.g., `which java-functional-lsp`).
+
+## Step 1: Install LSP4IJ Plugin
+
+1. Open IntelliJ IDEA
+2. Go to **Settings** → **Plugins** → **Marketplace**
+3. Search for **"LSP4IJ"**
+4. Click **Install** and restart the IDE
+
+## Step 2: Add Language Server
+
+1. Go to **Settings** → **Languages & Frameworks** → **Language Servers**
+2. Click the **`+`** button to add a new server
+3. Configure:
+
+| Field | Value |
+|-------|-------|
+| **Name** | `Java Functional LSP` |
+| **Command** | `java-functional-lsp` |
+
+> **PATH issues?** If IntelliJ can't find the binary, use the full path:
+> - Homebrew: `/opt/homebrew/bin/java-functional-lsp`
+> - pip: `~/.local/bin/java-functional-lsp` (or check with `which java-functional-lsp`)
+>
+> On macOS, you can also use: `sh -c java-functional-lsp`
+
+## Step 3: Configure File Mappings
+
+In the **Mappings** tab of the server configuration, add mappings so the LSP server activates for Java files. Set up **all three** sub-tabs:
+
+**Language** tab:
+1. Click **`+`** → select **Java**
+
+**File type** tab:
+1. Click **`+`** → select **Java**
+
+**File name patterns** tab:
+1. Click **`+`** to add a pattern
+2. Set **File name patterns**: `*.java`
+3. Set **Language Id**: `java`
+
+## Step 4: Verify
+
+1. Open any `.java` file in your project
+2. Check the bottom status bar — you should see the LSP server connecting
+3. Write code that triggers a rule (e.g., `return null;`) — a warning should appear
+
+## Configuration
+
+Project-level rules are configured via `.java-functional-lsp.json` in your project root. See the [main README](../../README.md) for details.
+
+## Coexistence with IntelliJ's Java Support
+
+LSP4IJ is designed to **supplement** IntelliJ's native Java support, not replace it. Your custom functional programming diagnostics appear alongside IntelliJ's built-in inspections. No conflicts.
+
+## Troubleshooting
+
+### Server doesn't start
+- Check **Settings** → **Languages & Frameworks** → **Language Servers** → select your server → **Traces** tab for error logs
+- Verify the binary works: run `java-functional-lsp check --help` in a terminal
+
+### No diagnostics appear
+- Ensure the file mapping is set to Language: `Java`, Language ID: `java`
+- Check that `.java-functional-lsp.json` doesn't have rules set to `"off"`
+- Try restarting the language server: **Tools** → **Language Servers** → **Restart**
+
+### PATH not found
+- IntelliJ may not inherit your shell's PATH. Use the full absolute path to the binary in the server command.

java_functional_lsp-0.3.0/editors/intellij/lsp4ij-template.json

@@ -0,0 +1,10 @@
+{
+  "name": "Java Functional LSP",
+  "command": "java-functional-lsp",
+  "mappings": [
+    {
+      "language": "Java",
+      "languageId": "java"
+    }
+  ]
+}

java_functional_lsp-0.3.0/editors/vscode/.vscodeignore

@@ -0,0 +1,6 @@
+src/**
+node_modules/**
+tsconfig.json
+.vscode/**
+**/*.ts
+**/*.map

java_functional_lsp-0.3.0/editors/vscode/README.md

@@ -0,0 +1,60 @@
+# Java Functional LSP — VS Code Extension
+
+Enforces functional programming best practices in Java files. Detects null usage, mutable state, exceptions, imperative loops, and Spring anti-patterns — and suggests functional alternatives using Vavr, Lombok, and idiomatic patterns.
+
+## Prerequisites
+
+Install the LSP server:
+
+```bash
+# Homebrew
+brew install aviadshiber/tap/java-functional-lsp
+
+# pip
+pip install java-functional-lsp
+```
+
+## Install the Extension
+
+### From VSIX (recommended)
+
+Download the latest `.vsix` from [GitHub Releases](https://github.com/aviadshiber/java-functional-lsp/releases), then:
+
+```bash
+code --install-extension java-functional-lsp-*.vsix
+```
+
+Or in VS Code: Extensions panel → `...` menu → "Install from VSIX..."
+
+### Build from Source
+
+```bash
+cd editors/vscode
+npm install
+npm run compile
+npx vsce package
+code --install-extension java-functional-lsp-*.vsix
+```
+
+## Configuration
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `javaFunctionalLsp.serverPath` | `"java-functional-lsp"` | Path to the LSP binary. Override if not on PATH. |
+| `javaFunctionalLsp.enabled` | `true` | Enable/disable the extension. |
+
+Example `settings.json`:
+
+```json
+{
+  "javaFunctionalLsp.serverPath": "/opt/homebrew/bin/java-functional-lsp"
+}
+```
+
+## Coexistence with Other Extensions
+
+This extension **coexists** with the Red Hat Java extension (`redhat.java`) and other Java extensions. Diagnostics from all servers are shown together — no configuration needed.
+
+## Rules
+
+See the [main README](../../README.md) for the full list of 12 rules and configuration options via `.java-functional-lsp.json`.