Add generic system tool detection with MVX_USE_SYSTEM_* environment variables

Implements a generic system tool detection mechanism that allows using
pre-installed tools instead of downloading them, addressing issue #2 with
a scalable solution for multiple tools.

Features:
- Generic useSystemTool(toolName) function for any tool
- SystemToolDetector interface for consistent detection pattern
- Individual environment variables: MVX_USE_SYSTEM_JAVA, MVX_USE_SYSTEM_MAVEN
- Extensible design for future tools (Node.js, Go, etc.)

Java Support (MVX_USE_SYSTEM_JAVA=true):
- Detection via JAVA_HOME environment variable
- Version parsing for both old (1.8.x) and new (21.x) formats
- Version compatibility validation
- Symlink integration with mvx tool management

Maven Support (MVX_USE_SYSTEM_MAVEN=true):
- Detection via MAVEN_HOME, M2_HOME, or mvn in PATH
- ANSI color code handling in version parsing
- Version compatibility validation
- Symlink integration with mvx tool management

Benefits:
- Faster CI builds (no download time)
- More reliable (avoids network issues)
- Better resource usage (uses existing installations)
- Selective control (enable/disable per tool)
- Backward compatible (no changes to existing behavior)
- Robust fallback (downloads when system tools unavailable)

Testing:
- Comprehensive unit tests for both Java and Maven
- Integration tests with proper development binary handling
- Benchmark tests with correct testing.B usage
- All existing tests pass with no breaking changes

Documentation:
- Updated README.md with multi-tool CI examples
- Updated website/content/tools.md with detailed usage
- GitHub Actions examples showing multiple tools

Closes #2

Author: gnodet

README.md

@@ -413,6 +413,74 @@ mvx automatically detects the configuration format:
 - Simplified CI/CD setup
 - Better collaboration with consistent tooling
 
+## 🚀 CI/CD Integration
+
+mvx is designed to work seamlessly in CI/CD environments. For faster builds and better reliability, you can configure mvx to use pre-installed tools instead of downloading them.
+
+### Using System Tools in CI
+
+When running in CI environments like GitHub Actions, the runners often have tools like Java and Maven pre-installed. You can configure mvx to use system tools instead of downloading them:
+
+```bash
+# Use system Java
+export MVX_USE_SYSTEM_JAVA=true
+
+# Use system Maven
+export MVX_USE_SYSTEM_MAVEN=true
+
+# Use system Node.js (when implemented)
+export MVX_USE_SYSTEM_NODE=true
+
+./mvx setup
+./mvx build
+```
+
+**Supported Tools:**
+- ✅ **Java**: Uses `JAVA_HOME` environment variable
+- ✅ **Maven**: Uses `MAVEN_HOME`, `M2_HOME`, or finds `mvn` in PATH
+- 🚧 **Node.js**: Coming soon
+- 🚧 **Go**: Coming soon
+
+**Benefits:**
+- ⚡ **Faster builds**: No time spent downloading tools
+- 🛡️ **More reliable**: Avoids network/download issues
+- 💾 **Better resource usage**: Uses existing installations
+- 🎯 **Selective control**: Enable/disable per tool independently
+
+**Example GitHub Actions workflow:**
+
+```yaml
+name: Build
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Set up Maven
+        uses: actions/setup-maven@v4
+        with:
+          maven-version: '3.9.6'
+
+      - name: Build with mvx
+        env:
+          MVX_USE_SYSTEM_JAVA: true
+          MVX_USE_SYSTEM_MAVEN: true
+        run: |
+          ./mvx setup
+          ./mvx build
+```
+
+This approach works with any CI system that provides Java pre-installed or allows you to install it separately.
+
 ## 💡 Example Configuration
 
 mvx supports both **JSON5** and **YAML** configuration formats, inspired by [Maven Mason](https://github.com/maveniverse/mason).

pkg/tools/java.go

@@ -29,6 +29,16 @@ func logVerbose(format string, args ...interface{}) {
 	}
 }
 
+// useSystemJava checks if system Java should be used instead of downloading
+func useSystemJava() bool {
+	return useSystemTool("java")
+}
+
+// getSystemJavaDetector returns a system detector for Java
+func getSystemJavaDetector() SystemToolDetector {
+	return &JavaSystemDetector{}
+}
+
 // JavaTool implements Tool interface for Java/JDK management
 type JavaTool struct {
 	manager *Manager
@@ -48,6 +58,31 @@ func (j *JavaTool) Install(version string, cfg config.ToolConfig) error {
 
 	installDir := j.manager.GetToolVersionDir("java", version, distribution)
 
+	// Check if we should use system Java instead of downloading
+	if useSystemJava() {
+		logVerbose("%s=true, attempting to use system Java", getSystemToolEnvVar("java"))
+
+		detector := getSystemJavaDetector()
+		systemJavaHome, err := detector.GetSystemHome()
+		if err != nil {
+			logVerbose("System Java not available: %v", err)
+			fmt.Printf("  ⚠️  System Java not available (%v), falling back to download\n", err)
+		} else {
+			systemVersion, err := detector.GetSystemVersion(systemJavaHome)
+			if err != nil {
+				logVerbose("Could not determine system Java version: %v", err)
+				fmt.Printf("  ⚠️  Could not determine system Java version (%v), falling back to download\n", err)
+			} else if !detector.IsVersionCompatible(systemVersion, version) {
+				logVerbose("System Java version %s does not match requested version %s", systemVersion, version)
+				fmt.Printf("  ⚠️  System Java version %s does not match requested version %s, falling back to download\n", systemVersion, version)
+			} else {
+				// Use system Java by creating a symlink
+				fmt.Printf("  🔗 Using system Java %s from JAVA_HOME: %s\n", systemVersion, systemJavaHome)
+				return detector.CreateSystemLink(systemJavaHome, installDir)
+			}
+		}
+	}
+
 	// Create installation directory
 	if err := os.MkdirAll(installDir, 0755); err != nil {
 		return fmt.Errorf("failed to create installation directory: %w", err)
@@ -75,6 +110,20 @@ func (j *JavaTool) IsInstalled(version string, cfg config.ToolConfig) bool {
 		distribution = "temurin"
 	}
 
+	// If using system Java, check if system Java is available and compatible
+	if useSystemJava() {
+		detector := getSystemJavaDetector()
+		if systemJavaHome, err := detector.GetSystemHome(); err == nil {
+			if systemVersion, err := detector.GetSystemVersion(systemJavaHome); err == nil {
+				if detector.IsVersionCompatible(systemVersion, version) {
+					logVerbose("System Java %s is available and compatible with requested version %s", systemVersion, version)
+					return true
+				}
+			}
+		}
+		// If system Java is not available or compatible, fall through to check downloaded version
+	}
+
 	// Try to get the actual Java path (which handles nested directories)
 	javaPath, err := j.GetPath(version, cfg)
 	if err != nil {
@@ -93,6 +142,20 @@ func (j *JavaTool) GetPath(version string, cfg config.ToolConfig) (string, error
 		distribution = "temurin"
 	}
 
+	// If using system Java, return system JAVA_HOME if available and compatible
+	if useSystemJava() {
+		detector := getSystemJavaDetector()
+		if systemJavaHome, err := detector.GetSystemHome(); err == nil {
+			if systemVersion, err := detector.GetSystemVersion(systemJavaHome); err == nil {
+				if detector.IsVersionCompatible(systemVersion, version) {
+					logVerbose("Using system Java %s from JAVA_HOME: %s", systemVersion, systemJavaHome)
+					return systemJavaHome, nil
+				}
+			}
+		}
+		// If system Java is not available or compatible, fall through to check downloaded version
+	}
+
 	installDir := j.manager.GetToolVersionDir("java", version, distribution)
 	logVerbose("Checking Java installation in: %s", installDir)
 

pkg/tools/java_test.go

@@ -0,0 +1,211 @@
+package tools
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/gnodet/mvx/pkg/config"
+)
+
+func TestUseSystemTool(t *testing.T) {
+	// Test when MVX_USE_SYSTEM_JAVA is not set
+	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
+	if useSystemTool("java") {
+		t.Error("useSystemTool('java') should return false when MVX_USE_SYSTEM_JAVA is not set")
+	}
+
+	// Test when MVX_USE_SYSTEM_JAVA is set to false
+	os.Setenv("MVX_USE_SYSTEM_JAVA", "false")
+	if useSystemTool("java") {
+		t.Error("useSystemTool('java') should return false when MVX_USE_SYSTEM_JAVA=false")
+	}
+
+	// Test when MVX_USE_SYSTEM_JAVA is set to true
+	os.Setenv("MVX_USE_SYSTEM_JAVA", "true")
+	if !useSystemTool("java") {
+		t.Error("useSystemTool('java') should return true when MVX_USE_SYSTEM_JAVA=true")
+	}
+
+	// Test Maven tool
+	os.Unsetenv("MVX_USE_SYSTEM_MAVEN")
+	if useSystemTool("maven") {
+		t.Error("useSystemTool('maven') should return false when MVX_USE_SYSTEM_MAVEN is not set")
+	}
+
+	os.Setenv("MVX_USE_SYSTEM_MAVEN", "true")
+	if !useSystemTool("maven") {
+		t.Error("useSystemTool('maven') should return true when MVX_USE_SYSTEM_MAVEN=true")
+	}
+
+	// Clean up
+	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
+	os.Unsetenv("MVX_USE_SYSTEM_MAVEN")
+}
+
+func TestUseSystemJava(t *testing.T) {
+	// Test when MVX_USE_SYSTEM_JAVA is not set
+	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
+	if useSystemJava() {
+		t.Error("useSystemJava() should return false when MVX_USE_SYSTEM_JAVA is not set")
+	}
+
+	// Test when MVX_USE_SYSTEM_JAVA is set to false
+	os.Setenv("MVX_USE_SYSTEM_JAVA", "false")
+	if useSystemJava() {
+		t.Error("useSystemJava() should return false when MVX_USE_SYSTEM_JAVA=false")
+	}
+
+	// Test when MVX_USE_SYSTEM_JAVA is set to true
+	os.Setenv("MVX_USE_SYSTEM_JAVA", "true")
+	if !useSystemJava() {
+		t.Error("useSystemJava() should return true when MVX_USE_SYSTEM_JAVA=true")
+	}
+
+	// Clean up
+	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
+}
+
+func TestJavaSystemDetector(t *testing.T) {
+	detector := &JavaSystemDetector{}
+
+	// Save original JAVA_HOME
+	originalJavaHome := os.Getenv("JAVA_HOME")
+	defer func() {
+		if originalJavaHome != "" {
+			os.Setenv("JAVA_HOME", originalJavaHome)
+		} else {
+			os.Unsetenv("JAVA_HOME")
+		}
+	}()
+
+	// Test when JAVA_HOME is not set
+	os.Unsetenv("JAVA_HOME")
+	_, err := detector.GetSystemHome()
+	if err == nil {
+		t.Error("GetSystemHome() should return error when JAVA_HOME is not set")
+	}
+
+	// Test when JAVA_HOME points to non-existent directory
+	os.Setenv("JAVA_HOME", "/non/existent/path")
+	_, err = detector.GetSystemHome()
+	if err == nil {
+		t.Error("GetSystemHome() should return error when JAVA_HOME points to non-existent directory")
+	}
+}
+
+func TestJavaSystemDetectorVersion(t *testing.T) {
+	detector := &JavaSystemDetector{}
+
+	// This test requires a real Java installation, so we'll skip it if JAVA_HOME is not set
+	javaHome := os.Getenv("JAVA_HOME")
+	if javaHome == "" {
+		t.Skip("Skipping test because JAVA_HOME is not set")
+	}
+
+	// Check if Java executable exists
+	javaExe := filepath.Join(javaHome, "bin", "java")
+	if runtime.GOOS == "windows" {
+		javaExe += ".exe"
+	}
+
+	if _, err := os.Stat(javaExe); err != nil {
+		t.Skip("Skipping test because Java executable not found at JAVA_HOME")
+	}
+
+	version, err := detector.GetSystemVersion(javaHome)
+	if err != nil {
+		t.Errorf("GetSystemVersion() failed: %v", err)
+	}
+
+	if version == "" {
+		t.Error("GetSystemVersion() returned empty version")
+	}
+
+	t.Logf("Detected Java version: %s", version)
+}
+
+func TestJavaVersionCompatibility(t *testing.T) {
+	detector := &JavaSystemDetector{}
+
+	tests := []struct {
+		systemVersion    string
+		requestedVersion string
+		expected         bool
+	}{
+		{"21", "21", true},
+		{"17", "17", true},
+		{"11", "11", true},
+		{"8", "8", true},
+		{"21", "17", false},
+		{"17", "21", false},
+		{"11", "8", false},
+	}
+
+	for _, test := range tests {
+		result := detector.IsVersionCompatible(test.systemVersion, test.requestedVersion)
+		if result != test.expected {
+			t.Errorf("IsVersionCompatible(%s, %s) = %v, expected %v",
+				test.systemVersion, test.requestedVersion, result, test.expected)
+		}
+	}
+}
+
+func TestJavaToolWithSystemJava(t *testing.T) {
+	// Save original environment variables
+	originalUseSystemJava := os.Getenv("MVX_USE_SYSTEM_JAVA")
+	originalJavaHome := os.Getenv("JAVA_HOME")
+	defer func() {
+		if originalUseSystemJava != "" {
+			os.Setenv("MVX_USE_SYSTEM_JAVA", originalUseSystemJava)
+		} else {
+			os.Unsetenv("MVX_USE_SYSTEM_JAVA")
+		}
+		if originalJavaHome != "" {
+			os.Setenv("JAVA_HOME", originalJavaHome)
+		} else {
+			os.Unsetenv("JAVA_HOME")
+		}
+	}()
+
+	// Create a mock manager
+	manager, err := NewManager()
+	if err != nil {
+		t.Fatalf("Failed to create manager: %v", err)
+	}
+
+	javaTool := &JavaTool{manager: manager}
+
+	// Test with MVX_USE_SYSTEM_JAVA=false (default behavior)
+	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
+	os.Unsetenv("JAVA_HOME")
+
+	cfg := config.ToolConfig{
+		Version:      "11", // Use version 11 which won't be installed
+		Distribution: "temurin",
+	}
+
+	// IsInstalled should return false when no Java is installed and MVX_USE_SYSTEM_JAVA is not set
+	if javaTool.IsInstalled("11", cfg) {
+		t.Error("IsInstalled should return false when no Java is installed")
+	}
+
+	// Test with MVX_USE_SYSTEM_JAVA=true but no JAVA_HOME
+	os.Setenv("MVX_USE_SYSTEM_JAVA", "true")
+	os.Unsetenv("JAVA_HOME")
+
+	// IsInstalled should still return false when JAVA_HOME is not set
+	if javaTool.IsInstalled("11", cfg) {
+		t.Error("IsInstalled should return false when MVX_USE_SYSTEM_JAVA=true but JAVA_HOME is not set")
+	}
+
+	// Test with MVX_USE_SYSTEM_JAVA=true and JAVA_HOME set but version mismatch
+	os.Setenv("MVX_USE_SYSTEM_JAVA", "true")
+	os.Setenv("JAVA_HOME", "/usr/lib/jvm/java-21-openjdk-amd64")
+
+	// IsInstalled should return false when system Java version doesn't match
+	if javaTool.IsInstalled("11", cfg) {
+		t.Error("IsInstalled should return false when system Java version doesn't match requested version")
+	}
+}