Implement automatic tool commands and improve Maven download strategy

- Add automatic tool command generation for all registered tools (go, java, node, etc.)
- Implement improved Maven/mvnd download strategy with alternating URLs instead of exhausting retries on first URL
- Add ExecuteTool method to executor for running mvx-managed tools
- Update CI workflow to use mvx-managed Go instead of GitHub Actions setup-go
- Tools are automatically detected from manager registry instead of hardcoded list
- Automatic commands work alongside existing dedicated commands (like mvn)
- Each tool command auto-installs the tool if needed and sets up proper environment

Author: gnodet

.github/workflows/ci.yml

@@ -70,7 +70,7 @@ jobs:
       - name: Run integration tests
         run: |
           cd test
-          go test -v -timeout=5m ./...
+          go test -v -timeout=10m ./...
 
       - name: Run benchmarks
         run: |

cmd/root.go

@@ -60,12 +60,18 @@ func Execute() error {
 		return fmt.Errorf("auto-setup failed: %w", err)
 	}
 
-	// Add dynamic custom commands before execution
+	// Add dynamic custom commands and tool commands before execution
 	if err := addCustomCommands(); err != nil {
 		// If we can't load custom commands, continue with built-in commands only
 		printVerbose("Failed to load custom commands: %v", err)
 	}
 
+	// Add automatic tool commands
+	if err := addToolCommands(); err != nil {
+		// If we can't load tool commands, continue without them
+		printVerbose("Failed to load tool commands: %v", err)
+	}
+
 	return rootCmd.Execute()
 }
 
@@ -384,6 +390,86 @@ func createCustomCommand(cmdName string, cmdConfig config.CommandConfig, exec *e
 	return cmd
 }
 
+// addToolCommands dynamically adds tool commands (mvn, go, node, etc.) as top-level commands
+func addToolCommands() error {
+	// Try to find project root and load configuration
+	projectRoot, err := findProjectRoot()
+	if err != nil {
+		return err // No project root found, skip tool commands
+	}
+
+	// Load configuration
+	cfg, err := config.LoadConfig(projectRoot)
+	if err != nil {
+		return err // No configuration found, skip tool commands
+	}
+
+	// Create tool manager
+	manager, err := tools.NewManager()
+	if err != nil {
+		return fmt.Errorf("failed to create tool manager: %w", err)
+	}
+
+	// Create executor
+	exec := executor.NewExecutor(cfg, manager, projectRoot)
+
+	// Get all registered tool names from the manager
+	registeredToolNames := manager.GetToolNames()
+
+	for _, toolName := range registeredToolNames {
+		// Check if this tool is configured in the project
+		if _, exists := cfg.Tools[toolName]; !exists {
+			continue // Skip tools not configured in this project
+		}
+
+		// Check if a command with this name already exists (avoid conflicts)
+		if hasCommand(rootCmd, toolName) {
+			continue // Skip if command already exists
+		}
+
+		// Create the tool command
+		toolCmd := createToolCommand(toolName, exec)
+		rootCmd.AddCommand(toolCmd)
+		printVerbose("Added automatic tool command: %s", toolName)
+	}
+
+	return nil
+}
+
+// hasCommand checks if a command with the given name already exists
+func hasCommand(cmd *cobra.Command, name string) bool {
+	for _, subCmd := range cmd.Commands() {
+		if subCmd.Name() == name {
+			return true
+		}
+	}
+	return false
+}
+
+// createToolCommand creates a cobra command for a specific tool
+func createToolCommand(toolName string, exec *executor.Executor) *cobra.Command {
+	return &cobra.Command{
+		Use:   toolName + " [tool-args...]",
+		Short: fmt.Sprintf("Run %s with mvx-managed environment", toolName),
+		Long: fmt.Sprintf(`Run %s with the mvx-managed %s installation and proper environment setup.
+
+This command automatically uses the %s version specified in your mvx configuration
+and sets up the appropriate environment variables.
+
+Examples:
+  mvx %s --version           # Show %s version
+  mvx %s [args...]           # Run %s with arguments`, toolName, toolName, toolName, toolName, toolName, toolName, toolName),
+
+		DisableFlagParsing: true, // Allow all flags to be passed through to the tool
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := exec.ExecuteTool(toolName, args); err != nil {
+				printError("%v", err)
+				os.Exit(1)
+			}
+		},
+	}
+}
+
 // isBuiltinCommand checks if a command name is a built-in mvx command
 func isBuiltinCommand(commandName string) bool {
 	builtinCommands := map[string]bool{

pkg/executor/executor.go

@@ -74,6 +74,63 @@ func (e *Executor) ExecuteCommand(commandName string, args []string) error {
 	return e.executeScriptWithInterpreter(processedScript, workDir, env, interpreter)
 }
 
+// ExecuteTool executes a tool command with mvx-managed environment
+func (e *Executor) ExecuteTool(toolName string, args []string) error {
+	// Check if the tool is configured
+	toolConfig, exists := e.config.Tools[toolName]
+	if !exists {
+		return fmt.Errorf("tool %s is not configured in this project", toolName)
+	}
+
+	// Get the tool instance
+	tool, err := e.toolManager.GetTool(toolName)
+	if err != nil {
+		return fmt.Errorf("failed to get tool %s: %w", toolName, err)
+	}
+
+	// Resolve tool version using the manager
+	resolvedVersion, err := e.toolManager.ResolveVersion(toolName, toolConfig)
+	if err != nil {
+		return fmt.Errorf("failed to resolve %s version %s: %w", toolName, toolConfig.Version, err)
+	}
+
+	// Check if tool is installed, auto-install if needed
+	if !tool.IsInstalled(resolvedVersion, toolConfig) {
+		fmt.Printf("🔧 Auto-installing %s %s...\n", toolName, resolvedVersion)
+		if err := tool.Install(resolvedVersion, toolConfig); err != nil {
+			return fmt.Errorf("failed to install %s %s: %w", toolName, resolvedVersion, err)
+		}
+	}
+
+	// Get tool binary path
+	toolBinPath, err := tool.GetPath(resolvedVersion, toolConfig)
+	if err != nil {
+		return fmt.Errorf("failed to get %s binary path: %w", toolName, err)
+	}
+
+	// Setup environment with tool paths
+	env, err := e.setupToolEnvironment(toolName, toolBinPath)
+	if err != nil {
+		return fmt.Errorf("failed to setup environment for %s: %w", toolName, err)
+	}
+
+	// Execute the tool
+	toolExecutable := toolName
+	if len(args) == 0 {
+		args = []string{"--version"} // Default to showing version if no args
+	}
+
+	// Create and execute command
+	cmd := exec.Command(toolExecutable, args...)
+	cmd.Env = env
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+	cmd.Dir = e.projectRoot
+
+	return cmd.Run()
+}
+
 // ExecuteBuiltinCommand executes a built-in command with optional hooks and overrides
 func (e *Executor) ExecuteBuiltinCommand(commandName string, args []string, builtinFunc func([]string) error) error {
 	// Check if command is overridden
@@ -388,3 +445,72 @@ func (e *Executor) ValidateCommand(commandName string) error {
 
 	return nil
 }
+
+// setupToolEnvironment prepares the environment for tool execution
+func (e *Executor) setupToolEnvironment(toolName, toolBinPath string) ([]string, error) {
+	// Create environment map starting with current environment
+	envVars := make(map[string]string)
+	for _, envVar := range os.Environ() {
+		parts := strings.SplitN(envVar, "=", 2)
+		if len(parts) == 2 {
+			envVars[parts[0]] = parts[1]
+		}
+	}
+
+	// Add global environment variables from config
+	globalEnv, err := e.toolManager.SetupEnvironment(e.config)
+	if err != nil {
+		return nil, err
+	}
+
+	for key, value := range globalEnv {
+		envVars[key] = value
+	}
+
+	// Add tool binary directory to PATH
+	pathDirs := []string{toolBinPath}
+
+	// Add existing PATH
+	if existingPath, exists := envVars["PATH"]; exists {
+		pathDirs = append(pathDirs, existingPath)
+	}
+
+	// Set PATH with tool directory first
+	envVars["PATH"] = strings.Join(pathDirs, string(os.PathListSeparator))
+
+	// Set tool-specific environment variables
+	switch toolName {
+	case "go":
+		// Set GOROOT if we can determine it from the binary path
+		if strings.HasSuffix(toolBinPath, "/bin") {
+			goRoot := strings.TrimSuffix(toolBinPath, "/bin")
+			envVars["GOROOT"] = goRoot
+		}
+	case "java":
+		// Set JAVA_HOME if we can determine it from the binary path
+		if strings.HasSuffix(toolBinPath, "/bin") {
+			javaHome := strings.TrimSuffix(toolBinPath, "/bin")
+			envVars["JAVA_HOME"] = javaHome
+		}
+	case "mvn", "maven":
+		// Set MAVEN_HOME if we can determine it from the binary path
+		if strings.HasSuffix(toolBinPath, "/bin") {
+			mavenHome := strings.TrimSuffix(toolBinPath, "/bin")
+			envVars["MAVEN_HOME"] = mavenHome
+		}
+	case "mvnd":
+		// Set MVND_HOME if we can determine it from the binary path
+		if strings.HasSuffix(toolBinPath, "/bin") {
+			mvndHome := strings.TrimSuffix(toolBinPath, "/bin")
+			envVars["MVND_HOME"] = mvndHome
+		}
+	}
+
+	// Convert map back to slice
+	env := make([]string, 0, len(envVars))
+	for key, value := range envVars {
+		env = append(env, fmt.Sprintf("%s=%s", key, value))
+	}
+
+	return env, nil
+}

pkg/tools/maven.go

@@ -135,22 +135,17 @@ func (m *MavenTool) installWithFallback(version string, cfg config.ToolConfig) e
 		return InstallError("maven", version, fmt.Errorf("failed to create install directory: %w", err))
 	}
 
-	// Try primary URL first
+	// Try both URLs with reduced retries instead of exhausting retries on first URL
 	primaryURL := m.getDownloadURL(version)
+	archiveURL := m.getArchiveDownloadURL(version)
 	m.PrintDownloadMessage(version)
 
 	options := m.GetDownloadOptions()
 
-	// Try to download from primary URL
-	archivePath, err := m.Download(primaryURL, version, cfg, options)
+	// Try to download with alternating URLs and reduced retries per URL
+	archivePath, err := m.downloadWithAlternatingURLs(primaryURL, archiveURL, version, cfg, options)
 	if err != nil {
-		// If primary URL fails, try archive URL
-		fmt.Printf("  🔄 Primary download failed, trying archive URL...\n")
-		archiveURL := m.getArchiveDownloadURL(version)
-		archivePath, err = m.Download(archiveURL, version, cfg, options)
-		if err != nil {
-			return InstallError("maven", version, fmt.Errorf("both primary and archive downloads failed: %w", err))
-		}
+		return InstallError("maven", version, fmt.Errorf("download failed from both primary and archive URLs: %w", err))
 	}
 	defer os.Remove(archivePath) // Clean up downloaded file
 
@@ -392,3 +387,65 @@ func (m *MavenTool) fetchChecksumFromURL(url string) (string, error) {
 
 	return checksum, nil
 }
+
+// downloadWithAlternatingURLs tries downloading from both URLs with reduced retries per URL
+// instead of exhausting all retries on the first URL before trying the second
+func (m *MavenTool) downloadWithAlternatingURLs(primaryURL, archiveURL, version string, cfg config.ToolConfig, options DownloadOptions) (string, error) {
+	urls := []struct {
+		url  string
+		name string
+	}{
+		{primaryURL, "primary"},
+		{archiveURL, "archive"},
+	}
+
+	maxRetries := 3    // Total retries across both URLs
+	retriesPerURL := 1 // Reduced retries per URL to allow trying both
+
+	var lastErr error
+
+	for attempt := 0; attempt < maxRetries; attempt++ {
+		urlIndex := attempt % len(urls)
+		currentURL := urls[urlIndex]
+
+		if attempt > 0 && urlIndex == 0 {
+			fmt.Printf("  🔄 Trying %s URL again (attempt %d)...\n", currentURL.name, (attempt/len(urls))+1)
+		} else if urlIndex == 1 {
+			fmt.Printf("  🔄 Switching to %s URL...\n", currentURL.name)
+		}
+
+		// Create download config with reduced retries per URL
+		downloadConfig := DefaultDownloadConfig(currentURL.url, "")
+		downloadConfig.MaxRetries = retriesPerURL
+		downloadConfig.ExpectedType = options.ExpectedType
+		downloadConfig.MinSize = options.MinSize
+		downloadConfig.MaxSize = options.MaxSize
+		downloadConfig.ToolName = "maven"
+		downloadConfig.Version = version
+		downloadConfig.Config = cfg
+		downloadConfig.ChecksumRegistry = m.manager.GetChecksumRegistry()
+		downloadConfig.Tool = m
+
+		// Create temporary file for download
+		tmpFile, err := os.CreateTemp("", fmt.Sprintf("maven-*%s", options.FileExtension))
+		if err != nil {
+			lastErr = fmt.Errorf("failed to create temporary file: %w", err)
+			continue
+		}
+		downloadConfig.DestPath = tmpFile.Name()
+		tmpFile.Close()
+
+		_, err = RobustDownload(downloadConfig)
+		if err == nil {
+			fmt.Printf("  ✅ Successfully downloaded from %s URL\n", currentURL.name)
+			return downloadConfig.DestPath, nil
+		}
+
+		lastErr = err
+		fmt.Printf("  ⚠️  Download from %s URL failed: %v\n", currentURL.name, err)
+		// Clean up failed download
+		os.Remove(downloadConfig.DestPath)
+	}
+
+	return "", fmt.Errorf("all download attempts failed, last error: %w", lastErr)
+}