Add shell activation support for automatic environment setup

This commit introduces comprehensive shell activation functionality that allows mvx to automatically set up development environments when entering directories with .mvx configuration.

Key features:
- Shell integration for bash, zsh, fish, and PowerShell
- Automatic PATH management with mvx-managed tools
- Environment variable setup from configuration
- Directory change detection for efficient activation
- Deactivation support for all shells
- Bootstrap script detection with fallback to global mvx

New commands:
- 'mvx activate <shell>' - Generate shell integration code
- 'mvx deactivate' - Provide deactivation instructions
- 'mvx env' - Output environment variables for shell integration

The activation system works by:
1. Installing shell hooks that detect directory changes
2. Looking for .mvx directories in current/parent directories
3. Running 'mvx env' to get tool paths and environment variables
4. Evaluating the output to update the shell environment

This provides a seamless development experience similar to tools like mise, direnv, and asdf, where tools become automatically available when entering project directories.

Documentation includes:
- Updated README with shell activation quick start
- Comprehensive shell activation guide on website
- Examples for all supported shells
- Integration with existing mvx workflow

All tests pass and the implementation follows mvx patterns for tool management and configuration handling.

Author: gnodet

README.md

@@ -200,6 +200,37 @@ cd mvx
 ./mvx test
 ```
 
+## 🔄 Shell Activation
+
+For a seamless development experience, enable shell activation to automatically set up your environment when entering project directories:
+
+**Bash** - Add to `~/.bashrc`:
+```bash
+eval "$(mvx activate bash)"
+```
+
+**Zsh** - Add to `~/.zshrc`:
+```bash
+eval "$(mvx activate zsh)"
+```
+
+**Fish** - Add to `~/.config/fish/config.fish`:
+```bash
+mvx activate fish | source
+```
+
+With shell activation enabled, tools become available automatically:
+
+```bash
+cd my-project
+# mvx: activating environment in /Users/you/my-project
+
+java -version  # Uses mvx-managed Java
+mvn -version   # Uses mvx-managed Maven
+```
+
+**Learn more**: See the [Shell Activation Guide](https://gnodet.github.io/mvx/shell-activation/) for detailed documentation.
+
 ## 🎯 Shell Completion
 
 mvx supports shell completion for commands and arguments across multiple shells (bash, zsh, fish, powershell):

cmd/activate.go

@@ -0,0 +1,148 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/gnodet/mvx/pkg/shell"
+	"github.com/spf13/cobra"
+)
+
+// activateCmd represents the activate command
+var activateCmd = &cobra.Command{
+	Use:   "activate [shell]",
+	Short: "Generate shell integration code for automatic environment activation",
+	Long: `Generate shell integration code that automatically activates mvx when entering
+directories with .mvx configuration.
+
+This command outputs shell-specific code that should be evaluated in your shell's
+configuration file (e.g., ~/.bashrc, ~/.zshrc, ~/.config/fish/config.fish).
+
+When activated, mvx will:
+  - Detect when you enter a directory with .mvx configuration
+  - Automatically update PATH with mvx-managed tools
+  - Set up environment variables from your configuration
+  - Cache the environment to avoid repeated setup
+
+Supported shells:
+  - bash
+  - zsh
+  - fish
+  - powershell
+
+Examples:
+  # Bash - add to ~/.bashrc
+  eval "$(mvx activate bash)"
+
+  # Zsh - add to ~/.zshrc
+  eval "$(mvx activate zsh)"
+
+  # Fish - add to ~/.config/fish/config.fish
+  mvx activate fish | source
+
+  # PowerShell - add to $PROFILE
+  Invoke-Expression (mvx activate powershell | Out-String)
+
+After adding to your shell configuration, restart your shell or source the file:
+  source ~/.bashrc    # bash
+  source ~/.zshrc     # zsh
+  source ~/.config/fish/config.fish  # fish
+
+Configuration:
+  MVX_VERBOSE=true        # Enable verbose output to see what mvx is doing`,
+
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		shellType := args[0]
+
+		// Validate shell type
+		validShells := []string{"bash", "zsh", "fish", "powershell"}
+		isValid := false
+		for _, s := range validShells {
+			if s == shellType {
+				isValid = true
+				break
+			}
+		}
+
+		if !isValid {
+			printError("Unsupported shell: %s", shellType)
+			printError("Supported shells: bash, zsh, fish, powershell")
+			os.Exit(1)
+		}
+
+		// Get the path to the mvx binary
+		mvxPath, err := getMvxBinaryPath()
+		if err != nil {
+			printError("Failed to determine mvx binary path: %v", err)
+			os.Exit(1)
+		}
+
+		// Generate shell hook
+		hook, err := shell.GenerateHook(shellType, mvxPath)
+		if err != nil {
+			printError("Failed to generate shell hook: %v", err)
+			os.Exit(1)
+		}
+
+		// Output the hook (this will be evaluated by the shell)
+		fmt.Print(hook)
+	},
+}
+
+// deactivateCmd represents the deactivate command
+var deactivateCmd = &cobra.Command{
+	Use:   "deactivate",
+	Short: "Deactivate mvx shell integration",
+	Long: `Deactivate mvx shell integration for the current shell session.
+
+This command is automatically available after running 'mvx activate' and
+removes mvx-managed tools from PATH and unsets mvx environment variables.
+
+Note: This only affects the current shell session. To permanently disable
+mvx activation, remove the 'eval "$(mvx activate ...)"' line from your
+shell configuration file.
+
+Examples:
+  mvx deactivate    # Remove mvx from current session`,
+
+	Run: func(cmd *cobra.Command, args []string) {
+		// This command is primarily handled by the shell hook itself
+		// When called directly, we just provide information
+		printInfo("To deactivate mvx in your current shell session:")
+		printInfo("")
+		printInfo("  Bash/Zsh:")
+		printInfo("    Run: mvx_deactivate")
+		printInfo("")
+		printInfo("  Fish:")
+		printInfo("    Run: mvx_deactivate")
+		printInfo("")
+		printInfo("  PowerShell:")
+		printInfo("    Run: mvx-deactivate")
+		printInfo("")
+		printInfo("To permanently disable mvx activation, remove the activation")
+		printInfo("line from your shell configuration file:")
+		printInfo("  - Bash: ~/.bashrc")
+		printInfo("  - Zsh: ~/.zshrc")
+		printInfo("  - Fish: ~/.config/fish/config.fish")
+		printInfo("  - PowerShell: $PROFILE")
+	},
+}
+
+// getMvxBinaryPath returns the path to the mvx binary
+func getMvxBinaryPath() (string, error) {
+	// Try to get the path from the current executable
+	exePath, err := os.Executable()
+	if err != nil {
+		return "", fmt.Errorf("failed to get executable path: %w", err)
+	}
+
+	// Resolve symlinks
+	exePath, err = filepath.EvalSymlinks(exePath)
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve symlinks: %w", err)
+	}
+
+	return exePath, nil
+}

cmd/activate_test.go

@@ -0,0 +1,196 @@
+package cmd
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/gnodet/mvx/pkg/shell"
+)
+
+func TestGetMvxBinaryPath(t *testing.T) {
+	path, err := getMvxBinaryPath()
+	if err != nil {
+		t.Fatalf("getMvxBinaryPath() failed: %v", err)
+	}
+
+	if path == "" {
+		t.Error("getMvxBinaryPath() returned empty path")
+	}
+
+	// Check that the path exists
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		t.Errorf("getMvxBinaryPath() returned non-existent path: %s", path)
+	}
+
+	t.Logf("mvx binary path: %s", path)
+}
+
+func TestActivateCommand(t *testing.T) {
+	// Save original args
+	originalArgs := os.Args
+	defer func() { os.Args = originalArgs }()
+
+	tests := []struct {
+		name           string
+		shell          string
+		expectedInHook []string
+		shouldError    bool
+	}{
+		{
+			name:  "bash activation",
+			shell: "bash",
+			expectedInHook: []string{
+				"# mvx shell integration for bash",
+				"_mvx_hook()",
+				"PROMPT_COMMAND",
+				"mvx_deactivate()",
+				".mvx",
+			},
+			shouldError: false,
+		},
+		{
+			name:  "zsh activation",
+			shell: "zsh",
+			expectedInHook: []string{
+				"# mvx shell integration for zsh",
+				"_mvx_hook()",
+				"precmd",
+				"mvx_deactivate()",
+				".mvx",
+			},
+			shouldError: false,
+		},
+		{
+			name:  "fish activation",
+			shell: "fish",
+			expectedInHook: []string{
+				"# mvx shell integration for fish",
+				"function _mvx_hook",
+				"--on-variable PWD",
+				"mvx_deactivate",
+				".mvx",
+			},
+			shouldError: false,
+		},
+		{
+			name:  "powershell activation",
+			shell: "powershell",
+			expectedInHook: []string{
+				"# mvx shell integration for PowerShell",
+				"function global:_mvx_hook",
+				"prompt",
+				"mvx-deactivate",
+				".mvx",
+			},
+			shouldError: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Capture stdout
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			// Set up command args
+			os.Args = []string{"mvx", "activate", tt.shell}
+
+			// Execute activate command
+			activateCmd.Run(activateCmd, []string{tt.shell})
+
+			// Restore stdout
+			w.Close()
+			os.Stdout = oldStdout
+
+			// Read captured output
+			buf := make([]byte, 10000)
+			n, _ := r.Read(buf)
+			output := string(buf[:n])
+
+			// Check for expected content
+			for _, expected := range tt.expectedInHook {
+				if !strings.Contains(output, expected) {
+					t.Errorf("Expected hook to contain '%s', but it didn't.\nOutput:\n%s", expected, output)
+				}
+			}
+
+			// Check that the hook contains the mvx binary path
+			mvxPath, _ := getMvxBinaryPath()
+			if !strings.Contains(output, mvxPath) {
+				t.Errorf("Expected hook to contain mvx binary path '%s', but it didn't.\nOutput:\n%s", mvxPath, output)
+			}
+
+			t.Logf("Generated hook for %s:\n%s", tt.shell, output)
+		})
+	}
+}
+
+func TestActivateCommandUnsupportedShell(t *testing.T) {
+	// Test that GenerateHook returns error for unsupported shell
+	_, err := shell.GenerateHook("unsupported-shell", "/usr/local/bin/mvx")
+	if err == nil {
+		t.Error("Expected error for unsupported shell, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "unsupported shell") {
+		t.Errorf("Expected error message about unsupported shell, got: %v", err)
+	}
+}
+
+func TestDeactivateCommand(t *testing.T) {
+	// Capture stdout
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	// Execute deactivate command
+	deactivateCmd.Run(deactivateCmd, []string{})
+
+	// Restore stdout
+	w.Close()
+	os.Stdout = oldStdout
+
+	// Read captured output
+	buf := make([]byte, 2000)
+	n, _ := r.Read(buf)
+	output := string(buf[:n])
+
+	// Check for expected content
+	expectedStrings := []string{
+		"deactivate mvx",
+		"Bash/Zsh",
+		"Fish",
+		"PowerShell",
+		"mvx_deactivate",
+		"mvx-deactivate",
+	}
+
+	for _, expected := range expectedStrings {
+		if !strings.Contains(output, expected) {
+			t.Errorf("Expected deactivate output to contain '%s', but it didn't.\nOutput:\n%s", expected, output)
+		}
+	}
+
+	t.Logf("Deactivate command output:\n%s", output)
+}
+
+func TestActivateCommandIntegration(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	// Build a test binary
+	tempDir := t.TempDir()
+	mvxBinary := filepath.Join(tempDir, "mvx-test")
+
+	// Note: This assumes we're running from the project root
+	// In a real test environment, you might need to adjust the path
+	t.Logf("Building test binary at %s", mvxBinary)
+
+	// For now, we'll skip the actual build and just test the command structure
+	// A full integration test would build the binary and test the actual shell hooks
+	t.Skip("Full integration test requires building binary - implement if needed")
+}