feat: Add comprehensive Java auto-detection

Implement robust Java installation detection that works across platforms:

- Add JavaConfig class to hold detection results
- Add detect_java_config() function with multi-step detection:
  1. Check JAVA_HOME environment variable
  2. Find javac executable and derive JAVA_HOME
  3. Search common installation directories by platform
- Support Linux, macOS, and Windows installation paths
- Properly configure JNI include paths (jni.h, jni_md.h)
- Find and link libjvm shared library
- Get Java version for logging

Changes to SConstruct:
- Change --without-java default to False (enable auto-detection)
- Use detect_java_config() for robust detection
- Only enable Java features if detection succeeds
- Add proper imports for os and subprocess modules

This enables Java plugin support to work out-of-the-box when a JDK
is installed, without requiring manual JAVA_HOME configuration.

Author: quinnjr

SConstruct

@@ -15,9 +15,11 @@ from os import environ, getenv
 from os.path import relpath, abspath
 import logging
 import re
+import subprocess
 from subprocess import call
 import sys
 import platform
+import os
 
 from build_config import *
 from build_support import *
@@ -95,8 +97,8 @@ AddOption(
     "--without-java",
     dest="without-java",
     action="store_true",
-    default=True,
-    help="Disable Java plugin compilation",
+    default=False,
+    help="Disable Java plugin support (auto-detected by default)",
 )
 
 AddOption(
@@ -312,28 +314,18 @@ if not env.GetOption("without-r"):
                 ]
             )
 
+java_enabled = False
 if not GetOption("without-java"):
-    java_home = getenv('JAVA_HOME');
-
-    if not java_home:
-        java_home = subprocess.check_output(["readlink", "-f", "/usr/bin/java"]).replace("/bin/java", "")
-
-    config.env.AppendUnique(
-        CPPPATH=[
-            Dir(java_home + "/include"),
-            Dir(java_home + "/include/" + sys.platform.lower())
-        ],
-        LIBPATH=[
-            Dir(java_home + "/include"),
-            Dir(java_home + "/include/" + sys.platform.lower())
-        ]
-    )
-
-    if not config.CheckHeader("jni.h"):
-        logging.error("!! Could not find `jni.h`")
-        Exit(1)
-
-    config.env.Append(CCPDEFINES=["HAVE_JAVA"])
+    java_config = detect_java_config()
+    if java_config.is_valid:
+        config.env.AppendUnique(CPPPATH=[Dir(p) for p in java_config.include_paths])
+        config.env.AppendUnique(LIBPATH=[Dir(p) for p in java_config.lib_paths])
+        config.env.Append(LIBS=["jvm"])
+        config.env.Append(CPPDEFINES=["HAVE_JAVA"])
+        java_enabled = True
+        logging.info(f"Java support enabled (JAVA_HOME: {java_config.java_home})")
+    else:
+        logging.warning("Java support requested but Java installation could not be found.")
 
 if GetOption("with-rust"):
     config.CheckProg("rustc")
@@ -393,7 +385,7 @@ if not env.GetOption("without-r"):
         "swig -r -c++ -module $TARGET -o ${TARGET}_wrap.cxx $SOURCE"
     )
 
-if not env.GetOption("without-java"):
+if java_enabled:
     env.Command(
         "JavaPluMA",
         "src/PluginWrapper.i",
@@ -458,7 +450,7 @@ if not env.GetOption('without-r'):
 
 ###################################################################
 # JAVA PLUGINS
-if not env.GetOption('without-java'):
+if java_enabled:
     env.SharedObject(
         source="JavaPluMA_wrap.cxx",
         target=ObjectPath("JavaPluMA_wrap.os"),

build_support.py

@@ -1,12 +1,14 @@
 #!python
-# Copyright (C) 2017, 2019-2020 FIUBioRG
+# Copyright (C) 2017, 2019-2020, 2026 FIUBioRG
 # SPDX-License-Identifier: MIT
 
 import os
 from os import path
 import subprocess
 from subprocess import Popen, PIPE
 import sys
+import glob
+import logging
 
 python_version = ".".join(map(str, sys.version_info[0:2]))
 
@@ -82,3 +84,235 @@ def CheckPerl(ctx):
     os.unlink(".perltest.pl")
 
     return retcode == 0
+
+
+###################################################################
+# JAVA DETECTION
+###################################################################
+
+class JavaConfig:
+    """Configuration holder for Java installation details."""
+    def __init__(self):
+        self.java_home = None
+        self.include_paths = []
+        self.lib_paths = []
+        self.libjvm_path = None
+        self.is_valid = False
+        self.version = None
+
+    def __repr__(self):
+        return f"JavaConfig(java_home={self.java_home}, valid={self.is_valid})"
+
+
+def detect_java_config():
+    """
+    Detect Java installation and return JavaConfig with paths.
+
+    Detection order:
+    1. JAVA_HOME environment variable
+    2. Location of javac executable
+    3. Common installation directories
+
+    Returns:
+        JavaConfig: Configuration object with detected paths
+    """
+    config = JavaConfig()
+
+    # Step 1: Check JAVA_HOME
+    java_home = os.environ.get("JAVA_HOME")
+
+    # Step 2: Try to find from javac location
+    if not java_home or not os.path.isdir(java_home):
+        java_home = _find_java_home_from_javac()
+
+    # Step 3: Search common installation directories
+    if not java_home or not os.path.isdir(java_home):
+        java_home = _search_common_java_locations()
+
+    if not java_home or not os.path.isdir(java_home):
+        logging.warning("Java installation not found")
+        return config
+
+    config.java_home = java_home
+
+    # Determine platform-specific include subdirectory
+    if sys.platform.startswith("linux"):
+        platform_dir = "linux"
+    elif sys.platform.startswith("darwin"):
+        platform_dir = "darwin"
+    elif sys.platform.startswith("win"):
+        platform_dir = "win32"
+    else:
+        platform_dir = sys.platform
+
+    # Configure include paths
+    include_dir = os.path.join(java_home, "include")
+    if os.path.isdir(include_dir):
+        config.include_paths.append(include_dir)
+        platform_include = os.path.join(include_dir, platform_dir)
+        if os.path.isdir(platform_include):
+            config.include_paths.append(platform_include)
+
+    # Configure library paths and find libjvm
+    lib_paths_to_check = [
+        os.path.join(java_home, "lib", "server"),
+        os.path.join(java_home, "lib", "client"),
+        os.path.join(java_home, "lib"),
+        os.path.join(java_home, "jre", "lib", "server"),
+        os.path.join(java_home, "jre", "lib", "amd64", "server"),
+        os.path.join(java_home, "jre", "lib", "i386", "server"),
+    ]
+
+    # macOS-specific paths
+    if sys.platform.startswith("darwin"):
+        lib_paths_to_check.extend([
+            os.path.join(java_home, "lib", "jli"),
+            os.path.join(java_home, "jre", "lib", "jli"),
+        ])
+
+    for lib_path in lib_paths_to_check:
+        if os.path.isdir(lib_path):
+            config.lib_paths.append(lib_path)
+            # Check for libjvm
+            if sys.platform.startswith("win"):
+                libjvm = os.path.join(lib_path, "jvm.dll")
+            elif sys.platform.startswith("darwin"):
+                libjvm = os.path.join(lib_path, "libjvm.dylib")
+            else:
+                libjvm = os.path.join(lib_path, "libjvm.so")
+
+            if os.path.isfile(libjvm):
+                config.libjvm_path = libjvm
+
+    # Validate: we need include paths and libjvm
+    jni_header = os.path.join(include_dir, "jni.h") if include_dir else None
+    if config.include_paths and (config.libjvm_path or config.lib_paths):
+        if jni_header and os.path.isfile(jni_header):
+            config.is_valid = True
+
+    # Try to get Java version
+    config.version = _get_java_version(java_home)
+
+    if config.is_valid:
+        logging.info(f"Java detected: {java_home} (version: {config.version})")
+    else:
+        logging.warning(f"Java installation at {java_home} is incomplete")
+
+    return config
+
+
+def _find_java_home_from_javac():
+    """Find JAVA_HOME by locating the javac executable."""
+    try:
+        # Try 'which javac' on Unix-like systems
+        if not sys.platform.startswith("win"):
+            result = subprocess.run(
+                ["which", "javac"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                javac_path = result.stdout.strip()
+                if javac_path:
+                    # Resolve symlinks
+                    real_path = os.path.realpath(javac_path)
+                    # javac is typically in JAVA_HOME/bin/javac
+                    java_home = os.path.dirname(os.path.dirname(real_path))
+                    if os.path.isdir(java_home):
+                        return java_home
+        else:
+            # Windows: try 'where javac'
+            result = subprocess.run(
+                ["where", "javac"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                javac_path = result.stdout.strip().split('\n')[0]
+                if javac_path:
+                    java_home = os.path.dirname(os.path.dirname(javac_path))
+                    if os.path.isdir(java_home):
+                        return java_home
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+
+    return None
+
+
+def _search_common_java_locations():
+    """Search common Java installation directories."""
+    search_patterns = []
+
+    if sys.platform.startswith("linux"):
+        search_patterns = [
+            "/usr/lib/jvm/java-*-openjdk*",
+            "/usr/lib/jvm/java-*-oracle*",
+            "/usr/lib/jvm/jdk-*",
+            "/usr/lib/jvm/java-*",
+            "/usr/lib/jvm/default-java",
+            "/usr/java/jdk*",
+            "/usr/java/latest",
+            "/opt/java/jdk*",
+            "/opt/jdk*",
+        ]
+    elif sys.platform.startswith("darwin"):
+        search_patterns = [
+            "/Library/Java/JavaVirtualMachines/*/Contents/Home",
+            "/System/Library/Java/JavaVirtualMachines/*/Contents/Home",
+            "/usr/local/opt/openjdk*/libexec/openjdk.jdk/Contents/Home",
+            "/opt/homebrew/opt/openjdk*/libexec/openjdk.jdk/Contents/Home",
+        ]
+    elif sys.platform.startswith("win"):
+        search_patterns = [
+            "C:/Program Files/Java/jdk*",
+            "C:/Program Files (x86)/Java/jdk*",
+            "C:/Program Files/Eclipse Adoptium/jdk*",
+            "C:/Program Files/Microsoft/jdk*",
+        ]
+
+    candidates = []
+    for pattern in search_patterns:
+        matches = glob.glob(pattern)
+        candidates.extend(matches)
+
+    # Sort by version (prefer newer versions)
+    candidates.sort(reverse=True)
+
+    # Return first valid candidate with include directory
+    for candidate in candidates:
+        include_dir = os.path.join(candidate, "include")
+        if os.path.isdir(include_dir) and os.path.isfile(os.path.join(include_dir, "jni.h")):
+            return candidate
+
+    return None
+
+
+def _get_java_version(java_home):
+    """Get Java version from the installation."""
+    try:
+        java_bin = os.path.join(java_home, "bin", "java")
+        if sys.platform.startswith("win"):
+            java_bin += ".exe"
+
+        if os.path.isfile(java_bin):
+            result = subprocess.run(
+                [java_bin, "-version"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            # Java outputs version to stderr
+            output = result.stderr or result.stdout
+            if output:
+                # Parse version from output like: openjdk version "11.0.11" or java version "1.8.0_291"
+                for line in output.split('\n'):
+                    if 'version' in line.lower():
+                        parts = line.split('"')
+                        if len(parts) >= 2:
+                            return parts[1]
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+
+    return "unknown"