Gradle lsp (zed-extensions#275)

# Add Gradle Language Server support (gRPC-driven build model)

## Summary

Adds Gradle build-file intelligence to the extension via Microsoft's
[Gradle Language Server](https://github.com/microsoft/vscode-gradle),
driven the same way the official VS Code Gradle extension drives it, by
running the bundled `gradle-server` over gRPC. A new native binary,
**`gradle-lsp-bridge`**, sits between Zed and the language server: it
keeps a single `gradle-server` process (and its Gradle daemon) warm for
the session, resolves the build model, and feeds it to the LS.

For **Groovy** `.gradle` scripts this gives plugin-aware completions
(closures, plugin-contributed blocks like `java {}`/`application {}`),
Maven Central dependency coordinates, and diagnostics. For **Kotlin**
`.gradle.kts` scripts it provides syntax highlighting plus
build-evaluation diagnostics (see below).

## Kotlin DSL handling

The Gradle Language Server is Groovy-only (it can't parse Kotlin), so
`.gradle.kts` doesn't get completions. But `gradle-server` itself runs
Gradle's Kotlin-DSL compiler during configuration and emits real errors
with file/line, the bridge captures these and surfaces them as editor
diagnostics, which **VS Code only logs**. The Groovy LS's own (invalid)
diagnostics for `.gradle.kts` are suppressed. Highlighting uses the
bundled Kotlin grammar via a dedicated `Gradle KTS` language, scoped by
longest-suffix-match so plain `.kt` files are unaffected.

## Architecture / refactors included

- **`proxy-common`** crate extracted: shared LSP framing +
parent-process monitor + `file://` URI helper, used by both native
binaries (keeps the JDTLS proxy lean: no async/gRPC stack leaks into
it).
- **`gradle-lsp-bridge`** built as a separate binary
(tokio/tonic/prost), so the gRPC dependency tree stays out of
`java-lsp-proxy`.
- Native binaries now share a single install directory via one constant
(aligns with the direction in zed-extensions#274).
- Build-eval diagnostics merged with the LS's own diagnostics per URI
(neither erases the other).

## Configuration

Gradle settings live under the `gradle-language-server` LSP block
(separate from `jdtls`). All optional works out of the box. Notably
`java_home` controls the JDK the Gradle daemon uses (17+); it's
configured per-server and falls back to `$JAVA_HOME`. Full reference in
the README's new **Gradle Build Files** section.

## Distribution

CI builds and ships `gradle-lsp-bridge-<os>-<arch>` assets alongside the
proxy on the same release tag, across the existing 6-target matrix.

## Testing

- Unit tests for the bridge: save/injected-response detectors,
diagnostics parsing (incl. the Kotlin-DSL failure shape), URI/framing
helpers, and the model→executeCommand mapping.
- Verified end-to-end against real Groovy and Kotlin-DSL projects:
completions appear, build errors surface as squiggles with correct
lines, and re-syncs after the daemon is warm are fast.
- Builds + clippy clean on macOS/Linux/Windows targets and the
`wasm32-wasip1` extension target.

Author: tartarughina

.github/workflows/release-proxy.yml

@@ -17,28 +17,34 @@ jobs:
         include:
           - target: aarch64-apple-darwin
             runner: macos-15
-            asset_name: java-lsp-proxy-darwin-aarch64.tar.gz
             helper_asset_name: java-task-helper-darwin-aarch64.tar.gz
+            proxy_asset: java-lsp-proxy-darwin-aarch64.tar.gz
+            bridge_asset: gradle-lsp-bridge-darwin-aarch64.tar.gz
           - target: x86_64-apple-darwin
             runner: macos-15-intel
-            asset_name: java-lsp-proxy-darwin-x86_64.tar.gz
             helper_asset_name: java-task-helper-darwin-x86_64.tar.gz
+            proxy_asset: java-lsp-proxy-darwin-x86_64.tar.gz
+            bridge_asset: gradle-lsp-bridge-darwin-x86_64.tar.gz
           - target: x86_64-unknown-linux-gnu
             runner: ubuntu-22.04
-            asset_name: java-lsp-proxy-linux-x86_64.tar.gz
             helper_asset_name: java-task-helper-linux-x86_64.tar.gz
+            proxy_asset: java-lsp-proxy-linux-x86_64.tar.gz
+            bridge_asset: gradle-lsp-bridge-linux-x86_64.tar.gz
           - target: aarch64-unknown-linux-gnu
             runner: ubuntu-22.04-arm
-            asset_name: java-lsp-proxy-linux-aarch64.tar.gz
             helper_asset_name: java-task-helper-linux-aarch64.tar.gz
+            proxy_asset: java-lsp-proxy-linux-aarch64.tar.gz
+            bridge_asset: gradle-lsp-bridge-linux-aarch64.tar.gz
           - target: x86_64-pc-windows-msvc
             runner: windows-latest
-            asset_name: java-lsp-proxy-windows-x86_64.zip
             helper_asset_name: java-task-helper-windows-x86_64.zip
+            proxy_asset: java-lsp-proxy-windows-x86_64.zip
+            bridge_asset: gradle-lsp-bridge-windows-x86_64.zip
           - target: aarch64-pc-windows-msvc
             runner: windows-11-arm
-            asset_name: java-lsp-proxy-windows-aarch64.zip
             helper_asset_name: java-task-helper-windows-aarch64.zip
+            proxy_asset: java-lsp-proxy-windows-aarch64.zip
+            bridge_asset: gradle-lsp-bridge-windows-aarch64.zip
 
     steps:
       - name: Checkout
@@ -49,9 +55,12 @@ jobs:
         with:
           targets: ${{ matrix.target }}
 
-      - name: Build proxy binary
-        working-directory: proxy
-        run: cargo build --release --target ${{ matrix.target }}
+      # Build both native binaries from the workspace root. Selecting the two
+      # packages explicitly keeps the WASM extension crate (`zed_java`, a
+      # cdylib) out of the native target build. The gradle-lsp-bridge gRPC
+      # bindings are committed, so no protoc toolchain is needed here.
+      - name: Build binaries
+        run: cargo build --release --target ${{ matrix.target }} -p java-lsp-proxy -p gradle-lsp-bridge
         shell: bash
 
       - name: Build task helper binary
@@ -62,27 +71,32 @@ jobs:
       - name: Package binaries (Unix)
         if: runner.os != 'Windows'
         run: |
-          tar -czf ${{ matrix.asset_name }} \
+          tar -czf ${{ matrix.proxy_asset }} \
             -C target/${{ matrix.target }}/release \
             java-lsp-proxy
           tar -czf ${{ matrix.helper_asset_name }} \
             -C target/${{ matrix.target }}/release \
             java-task-helper
+          tar -czf ${{ matrix.bridge_asset }} \
+            -C target/${{ matrix.target }}/release \
+            gradle-lsp-bridge
 
       - name: Package binaries (Windows)
         if: runner.os == 'Windows'
         shell: pwsh
-        run: |
-          Compress-Archive -Path target/${{ matrix.target }}/release/java-lsp-proxy.exe -DestinationPath ${{ matrix.asset_name }}
+        run: |          
           Compress-Archive -Path target/${{ matrix.target }}/release/java-task-helper.exe -DestinationPath ${{ matrix.helper_asset_name }}
+          Compress-Archive -Path target/${{ matrix.target }}/release/java-lsp-proxy.exe -DestinationPath ${{ matrix.proxy_asset }}
+          Compress-Archive -Path target/${{ matrix.target }}/release/gradle-lsp-bridge.exe -DestinationPath ${{ matrix.bridge_asset }}
 
       - name: Upload artifacts
         uses: actions/upload-artifact@v7
         with:
           name: binaries-${{ matrix.target }}
           path: |
-            ${{ matrix.asset_name }}
             ${{ matrix.helper_asset_name }}
+            ${{ matrix.proxy_asset }}
+            ${{ matrix.bridge_asset }}
           retention-days: 1
 
   release: