@franzmoca/opencode-lombok 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Francesco Moca
+
+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.

package/README.md

@@ -0,0 +1,70 @@
+# opencode-lombok
+
+`opencode-lombok` is an OpenCode plugin that adds Lombok support to Java projects.
+
+This plugin was inspired by [opencode PR #8031](https://github.com/anomalyco/opencode/pull/8031).
+
+It automatically:
+
+- detects Lombok usage in `pom.xml`, `build.gradle`, and `build.gradle.kts`
+- downloads `lombok.jar` when needed
+- configures `JAVA_TOOL_OPTIONS` with `-javaagent:<path-to-lombok.jar>` so JVM-based LSP servers (including JDTLS) pick it up
+
+If `JAVA_TOOL_OPTIONS` already exists, the plugin appends the Lombok javaagent and avoids duplicates.
+
+## Install
+
+Add the plugin to your OpenCode config:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@franzmoca/opencode-lombok"]
+}
+```
+
+You can also pin a specific version:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@franzmoca/opencode-lombok@0.1.0"]
+}
+```
+
+OpenCode will install npm plugins automatically at startup.
+
+## Behavior
+
+- If `lsp` is globally disabled (`"lsp": false`), the plugin does nothing.
+- If `jdtls` is explicitly disabled (`"lsp": { "jdtls": { "disabled": true } }`), the plugin does nothing.
+- If `OPENCODE_DISABLE_LSP_DOWNLOAD=true`, the plugin will not download `lombok.jar`.
+
+## Development
+
+```bash
+bun install
+bun run typecheck
+bun test
+bun run build
+```
+
+## Publish to npm
+
+```bash
+npm login
+npm publish --access public
+```
+
+Or use the GitHub Actions workflow:
+
+- `CI` runs typecheck, tests, and build on push/PR.
+- `Publish` runs on tags (`v*`) and publishes with `NPM_TOKEN`.
+
+### Required GitHub secret
+
+- `NPM_TOKEN`: npm automation token with publish rights for `@franzmoca/opencode-lombok`
+
+## License
+
+MIT

package/dist/core.d.ts

@@ -0,0 +1,8 @@
+export declare function hasLombokDependency(content: string): boolean;
+export declare function detectLombokDependency(projectRoot: string): Promise<boolean>;
+export declare function opencodeDataDir(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, home?: string): string;
+export declare function lombokJarPath(dataDir?: string): string;
+export declare function isLspDownloadDisabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function ensureLombokJar(file: string, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
+export declare function formatJavaAgentArg(file: string): string;
+export declare function mergeJavaToolOptions(current: string | undefined, file: string): string;

package/dist/core.js

@@ -0,0 +1,116 @@
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+const LOMBOK_URL = "https://projectlombok.org/downloads/lombok.jar";
+const BUILD_FILES = new Set(["pom.xml", "build.gradle", "build.gradle.kts"]);
+const SKIP_DIRS = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "target",
+    "out",
+    ".next",
+    ".turbo",
+]);
+const LOMBOK_MATCHERS = [
+    /<artifactId>\s*lombok\s*<\/artifactId>/,
+    /["']org\.projectlombok:lombok[:"']/,
+    /io\.freefair\.lombok/,
+];
+const LOMBOK_JAVA_AGENT = /-javaagent:(?:"[^"]*lombok\.jar"|[^ "']*lombok\.jar)/i;
+const pathExists = async (file) => fs
+    .stat(file)
+    .then(() => true)
+    .catch(() => false);
+const readEntries = async (dir) => {
+    return fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+};
+const readText = async (file) => {
+    return fs.readFile(file, "utf8").catch(() => "");
+};
+export function hasLombokDependency(content) {
+    return LOMBOK_MATCHERS.some((matcher) => matcher.test(content));
+}
+const containsLombokInFile = async (file) => {
+    const content = await readText(file);
+    if (!content)
+        return false;
+    return hasLombokDependency(content);
+};
+async function detectInDir(dir) {
+    const entries = await readEntries(dir);
+    for (const entry of entries) {
+        const file = path.join(dir, entry.name);
+        if (entry.isFile() && BUILD_FILES.has(entry.name)) {
+            const hit = await containsLombokInFile(file);
+            if (hit)
+                return true;
+        }
+        if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
+            const hit = await detectInDir(file);
+            if (hit)
+                return true;
+        }
+    }
+    return false;
+}
+export async function detectLombokDependency(projectRoot) {
+    return detectInDir(projectRoot);
+}
+export function opencodeDataDir(platform = process.platform, env = process.env, home = os.homedir()) {
+    if (env.XDG_DATA_HOME)
+        return path.join(env.XDG_DATA_HOME, "opencode");
+    if (platform === "darwin")
+        return path.join(home, "Library", "Application Support", "opencode");
+    if (platform === "win32") {
+        const appData = env.APPDATA || path.win32.join(home, "AppData", "Roaming");
+        return path.win32.join(appData, "opencode");
+    }
+    return path.join(home, ".local", "share", "opencode");
+}
+export function lombokJarPath(dataDir = opencodeDataDir()) {
+    return path.join(dataDir, "bin", "jdtls", "bin", "lombok.jar");
+}
+export function isLspDownloadDisabled(env = process.env) {
+    const value = env.OPENCODE_DISABLE_LSP_DOWNLOAD || "";
+    return /^(1|true|yes)$/i.test(value.trim());
+}
+export async function ensureLombokJar(file, env = process.env) {
+    const exists = await pathExists(file);
+    if (exists)
+        return file;
+    if (isLspDownloadDisabled(env))
+        return undefined;
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const response = await fetch(LOMBOK_URL).catch(() => undefined);
+    if (!response?.ok)
+        return undefined;
+    const body = await response.arrayBuffer().catch(() => undefined);
+    if (!body)
+        return undefined;
+    const saved = await fs
+        .writeFile(file, Buffer.from(body))
+        .then(() => true)
+        .catch(() => false);
+    if (!saved)
+        return undefined;
+    const present = await pathExists(file);
+    if (!present)
+        return undefined;
+    return file;
+}
+export function formatJavaAgentArg(file) {
+    if (!/\s/.test(file))
+        return `-javaagent:${file}`;
+    return `-javaagent:"${file.replace(/"/g, '\\"')}"`;
+}
+export function mergeJavaToolOptions(current, file) {
+    const existing = current?.trim() || "";
+    if (LOMBOK_JAVA_AGENT.test(existing))
+        return existing;
+    const agent = formatJavaAgentArg(file);
+    if (!existing)
+        return agent;
+    return `${existing} ${agent}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const LombokPlugin: Plugin;
+export default LombokPlugin;
+export * from "./core.js";

package/dist/index.js

@@ -0,0 +1,57 @@
+import { detectLombokDependency, ensureLombokJar, isLspDownloadDisabled, lombokJarPath, mergeJavaToolOptions, } from "./core.js";
+const SERVICE = "plugin.lombok";
+function jdtlsDisabled(lsp) {
+    if (!lsp || typeof lsp !== "object")
+        return false;
+    if (!("jdtls" in lsp))
+        return false;
+    const jdtls = lsp.jdtls;
+    if (!jdtls || typeof jdtls !== "object")
+        return false;
+    return Boolean(jdtls.disabled);
+}
+async function log(ctx, level, message, extra) {
+    await ctx.client.app
+        .log({
+        body: {
+            service: SERVICE,
+            level,
+            message,
+            extra,
+        },
+    })
+        .catch(() => { });
+}
+export const LombokPlugin = async (ctx) => {
+    return {
+        config: async (config) => {
+            if (config.lsp === false)
+                return;
+            if (jdtlsDisabled(config.lsp))
+                return;
+            const lombokDetected = await detectLombokDependency(ctx.directory);
+            if (!lombokDetected)
+                return;
+            await log(ctx, "info", "Lombok dependency detected");
+            const jar = await ensureLombokJar(lombokJarPath());
+            if (!jar) {
+                await log(ctx, "warn", "Lombok detected but lombok.jar is unavailable", {
+                    downloadDisabled: isLspDownloadDisabled(),
+                });
+                return;
+            }
+            const current = process.env.JAVA_TOOL_OPTIONS;
+            const next = mergeJavaToolOptions(current, jar);
+            process.env.JAVA_TOOL_OPTIONS = next;
+            if (next === (current?.trim() || "")) {
+                await log(ctx, "info", "JAVA_TOOL_OPTIONS already has a Lombok javaagent", { jarPath: jar });
+                return;
+            }
+            await log(ctx, "info", "Configured Lombok javaagent for JVM-based language servers", {
+                jarPath: jar,
+            });
+        },
+    };
+};
+export default LombokPlugin;
+export * from "./core.js";

package/package.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@franzmoca/opencode-lombok",
+  "version": "0.1.0",
+  "description": "OpenCode plugin that adds Lombok support for JDTLS",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/franzmoca/opencode-lombok.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run typecheck && bun test && bun run build"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "lombok",
+    "jdtls",
+    "java"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.1.14"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.9",
+    "typescript": "^5.8.2"
+  }
+}