feat: VSCode tools auto-install + go.mod version handling improvements (#554)

* [AB#542] Fix goenv vscode init

Currently goenv vscode init added a random json flag, and that's not correct. Clean up and remove the line from the JSON.

* feat: Add VSCode Go extension tools installation support

Add comprehensive VSCode tools management with automatic installation
support for all 8 required tools from the VSCode Go extension.

New Features:
- Add 'goenv tools install-vscode <version>' command to install all
  VSCode Go extension tools (gopls, dlv, vscgo, goplay, gomodifytags,
  impl, gotests, staticcheck)
- Add --install-tools flag to 'goenv vscode init' command
- Add --install-tools flag to 'goenv vscode setup' command

Bug Fixes:
- Fix vscgo package path to github.com/golang/vscode-go/vscgo
- Fix goplay package path to github.com/haya14busa/goplay/cmd/goplay
- Update documentation examples to use 'default-tools' instead of 'default'
- Fix test assertion to match new command name

Implementation Details:
- Add VSCodeTools list with all 8 required tools
- Add BuildVSCodeToolsConfig() helper for DRY configuration building
- Add InstallVSCodeToolsForVersion() shared installation logic
- Integrate tools installation into vscode init and setup workflows

Closes #542

* test: Add comprehensive tests for go.mod forward compatibility

Add test coverage for GetCurrentVersionResolved() with go.mod scenarios,
particularly for Go 1.26+ behavior where 'go mod init' defaults to (N-1).0.

Version selection strategy when go.mod is the version source:
  • Lowest minor version that satisfies the constraint (most conservative)
  • Highest patch of that minor (always want bug/security fixes)

Test scenarios include:
- PRIMARY: go.mod 1.25 + installed [1.25.4, 1.26.1, 1.27.0] → uses 1.25.4
  (validates lowest satisfying minor, highest patch strategy)
- Forward compatibility: go.mod 1.25 with only newer minors (1.26+)
  → uses minimum compatible (e.g., 1.26.0 over 1.27.0)
- Highest patch preference: multiple patches of target minor available
  → always selects highest patch (e.g., 1.25.4 over 1.25.2)
- Backward incompatibility: go.mod 1.26 with only older versions
  → errors correctly (can't use older version)
- Edge cases: no versions installed, full version specs

This validates the existing forward compatibility logic in
GetCurrentVersionResolved() and findCompatibleVersion() that allows
users with go.mod requiring Go 1.25 to successfully use Go 1.26+
while preferring exact minor matches when available.

Related to issue #542 (go.mod version handling)

* fix: Make cache timing tests more robust for Windows CI

Increase TTL and sleep durations in TestCacheGetStats and TestCachePrune
to account for Windows timing precision and slower CI environments.

Before:
- TestCacheGetStats: 100ms TTL with 50ms + 60ms sleeps
- TestCachePrune: 50ms TTL with 60ms sleep

After:
- TestCacheGetStats: 200ms TTL with 50ms + 160ms sleeps
- TestCachePrune: 100ms TTL with 120ms sleep

This provides more margin for test execution overhead while maintaining
the same test logic and coverage.

Author: ChronosMasterOfAllTime

cmd/core/current.go

@@ -52,7 +52,9 @@ func runCurrent(cmd *cobra.Command, args []string) error {
 	resolvedVersion, versionSpec, source, err := mgr.GetCurrentVersionResolved()
 	if err != nil {
 		if versionSpec != "" && source != "" {
-			return fmt.Errorf("goenv: version '%s' is not installed (set by %s)", versionSpec, source)
+			// Version specified but not installed - provide helpful error
+			installed, _ := mgr.ListInstalledVersions()
+			return errors.VersionNotInstalledDetailed(versionSpec, source, installed)
 		}
 		return errors.FailedTo("determine active version", err)
 	}

cmd/integrations/vscode.go

@@ -14,6 +14,7 @@ import (
 	"github.com/go-nv/goenv/internal/config"
 	"github.com/go-nv/goenv/internal/errors"
 	"github.com/go-nv/goenv/internal/helptext"
+	"github.com/go-nv/goenv/internal/tools"
 	"github.com/go-nv/goenv/internal/utils"
 	"github.com/go-nv/goenv/internal/vscode"
 	"github.com/spf13/cobra"
@@ -49,10 +50,15 @@ The settings configure:
   - go.toolsGopath for Go tools installation
   - Recommended Go extension
 
-This makes VS Code automatically detect and use goenv-managed Go versions.`,
+This makes VS Code automatically detect and use goenv-managed Go versions.
+
+Optionally install VSCode Go extension tools with --install-tools flag.`,
 	Example: `  # Initialize VS Code in current directory
   goenv vscode init
 
+  # Initialize and install VSCode tools
+  goenv vscode init --install-tools
+
   # Force overwrite existing configuration
   goenv vscode init --force
 
@@ -152,11 +158,15 @@ This command performs all necessary configuration:
   2. Initializes workspace .vscode/settings.json
   3. Syncs with current Go version
   4. Validates configuration (doctor checks)
+  5. Optionally installs VSCode Go extension tools (with --install-tools)
 
 Perfect for both first-time setup and fixing integration issues.`,
 	Example: `  # Complete VS Code setup in one command
   goenv vscode setup
 
+  # Setup and install all VSCode tools
+  goenv vscode setup --install-tools
+
   # Setup with advanced template
   goenv vscode setup --template advanced
 
@@ -180,6 +190,7 @@ var VSCodeInitFlags struct {
 	Launch         bool
 	TerminalEnv    bool
 	Devcontainer   bool
+	InstallTools   bool
 }
 
 var vscodeSyncFlags struct {
@@ -196,10 +207,11 @@ var vscodeDoctorFlags struct {
 }
 
 var vscodeSetupFlags struct {
-	template string
-	dryRun   bool
-	strict   bool
-	json     bool
+	template     string
+	dryRun       bool
+	strict       bool
+	json         bool
+	installTools bool
 }
 
 func init() {
@@ -223,6 +235,7 @@ func init() {
 	vscodeInitCmd.Flags().BoolVar(&VSCodeInitFlags.Launch, "launch", false, "Generate launch.json for debugging")
 	vscodeInitCmd.Flags().BoolVar(&VSCodeInitFlags.TerminalEnv, "terminal-env", false, "Configure integrated terminal environment")
 	vscodeInitCmd.Flags().BoolVar(&VSCodeInitFlags.Devcontainer, "devcontainer", false, "Generate .devcontainer configuration")
+	vscodeInitCmd.Flags().BoolVar(&VSCodeInitFlags.InstallTools, "install-tools", false, "Install VSCode Go extension tools after initialization")
 
 	// Sync flags
 	vscodeSyncCmd.Flags().BoolVar(&vscodeSyncFlags.dryRun, "dry-run", false, "Preview changes without writing files")
@@ -239,6 +252,7 @@ func init() {
 	vscodeSetupCmd.Flags().BoolVar(&vscodeSetupFlags.dryRun, "dry-run", false, "Preview what would be done")
 	vscodeSetupCmd.Flags().BoolVar(&vscodeSetupFlags.strict, "strict", false, "Exit with error if doctor validation fails")
 	vscodeSetupCmd.Flags().BoolVar(&vscodeSetupFlags.json, "json", false, "Output doctor results in JSON")
+	vscodeSetupCmd.Flags().BoolVar(&vscodeSetupFlags.installTools, "install-tools", false, "Install VSCode Go extension tools after setup")
 
 	vscodeSetupCmd.SilenceUsage = true
 	vscodeInitCmd.SilenceUsage = true
@@ -545,6 +559,18 @@ func InitializeVSCodeWorkspaceWithVersion(cmd *cobra.Command, version string) er
 	}
 	fmt.Fprintln(cmd.OutOrStdout(), "")
 
+	// Install VSCode tools if requested
+	if VSCodeInitFlags.InstallTools && !VSCodeInitFlags.DryRun {
+		fmt.Fprintln(cmd.OutOrStdout())
+		fmt.Fprintf(cmd.OutOrStdout(), "%sInstalling VSCode Go extension tools...\n", utils.Emoji("🔧 "))
+		fmt.Fprintln(cmd.OutOrStdout())
+
+		if err := installVSCodeTools(cmd, version); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "%sFailed to install tools: %v\n", utils.Emoji("⚠️  "), err)
+			fmt.Fprintln(cmd.OutOrStderr(), "You can install them later with: goenv tools install-vscode <version>")
+		}
+	}
+
 	return nil
 }
 
@@ -562,15 +588,13 @@ func generateSettings(template string) (VSCodeSettings, error) {
 			"go.goroot":      "${env:GOROOT}",
 			"go.gopath":      "${env:GOPATH}",
 			"go.toolsGopath": homeEnvVar + "/go/tools",
-			"goenv.autoSync": false, // Set to true to auto-update on version change
 		}, nil
 
 	case "advanced":
 		return VSCodeSettings{
 			"go.goroot":                         "${env:GOROOT}",
 			"go.gopath":                         "${env:GOPATH}",
 			"go.toolsGopath":                    homeEnvVar + "/go/tools",
-			"goenv.autoSync":                    false, // Set to true to auto-update on version change
 			"go.toolsManagement.autoUpdate":     true,
 			"go.formatTool":                     "gofumpt",
 			"go.lintTool":                       "golangci-lint",
@@ -598,7 +622,6 @@ func generateSettings(template string) (VSCodeSettings, error) {
 			"go.goroot":                          "${env:GOROOT}",
 			"go.gopath":                          "${env:GOPATH}",
 			"go.toolsGopath":                     homeEnvVar + "/go/tools",
-			"goenv.autoSync":                     false, // Set to true to auto-update on version change
 			"go.inferGopath":                     false,
 			"go.formatTool":                      "gofumpt",
 			"go.testExplorer.enable":             true,
@@ -1345,8 +1368,53 @@ func runVSCodeSetup(cmd *cobra.Command, args []string) error {
 			utils.Emoji("⚠️  "))
 	}
 
+	// Step 5: Install VSCode tools if requested
+	if vscodeSetupFlags.installTools && !vscodeSetupFlags.dryRun {
+		fmt.Fprintln(cmd.OutOrStdout())
+		fmt.Fprintf(cmd.OutOrStdout(), "%sStep 5/5: Installing VSCode Go extension tools\n",
+			utils.Emoji("🔧 "))
+
+		ctx := cmdutil.GetContexts(cmd)
+		mgr := ctx.Manager
+		version, _, _, err := mgr.GetCurrentVersionResolved()
+		if err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "%sFailed to get current Go version: %v\n", utils.Emoji("⚠️  "), err)
+			fmt.Fprintln(cmd.OutOrStderr(), "You can install tools later with: goenv tools install-vscode <version>")
+		} else {
+			if err := installVSCodeTools(cmd, version); err != nil {
+				fmt.Fprintf(cmd.OutOrStderr(), "%sFailed to install tools: %v\n", utils.Emoji("⚠️  "), err)
+				fmt.Fprintln(cmd.OutOrStderr(), "You can install them later with: goenv tools install-vscode <version>")
+			}
+		}
+	}
+
 	fmt.Fprintf(cmd.OutOrStdout(), "\n%sSetup complete! VS Code is ready to use with goenv.\n",
 		utils.Emoji("✅ "))
 
 	return nil
 }
+
+// installVSCodeTools installs all VSCode Go extension tools for the given Go version
+func installVSCodeTools(cmd *cobra.Command, goVersion string) error {
+	ctx := cmdutil.GetContexts(cmd)
+	cfg := ctx.Config
+	mgr := ctx.Manager
+
+	// Validate version is installed
+	if !mgr.IsVersionInstalled(goVersion) {
+		return fmt.Errorf("Go %s is not installed", goVersion)
+	}
+
+	versionPath := cfg.SafeResolvePath(goVersion)
+
+	// Install VSCode tools
+	if err := tools.InstallVSCodeToolsForVersion(goVersion, cfg.Root, versionPath, false); err != nil {
+		return err
+	}
+
+	fmt.Fprintln(cmd.OutOrStdout())
+	fmt.Fprintf(cmd.OutOrStdout(), "%sVSCode tools installed successfully\n", utils.Emoji("✅ "))
+	fmt.Fprintf(cmd.OutOrStdout(), "%sRun 'goenv rehash' to make tools available as shims\n", utils.Emoji("💡 "))
+
+	return nil
+}

cmd/tools/default_tools.go

@@ -24,11 +24,11 @@ Common use cases:
   - Reduce manual setup after installing new Go versions
 
 Examples:
-  goenv tools default list              # Show configured tools
-  goenv tools default init              # Create default config file
-  goenv tools default enable            # Enable auto-installation
-  goenv tools default disable           # Disable auto-installation
-  goenv tools default install 1.25.2    # Install tools for specific version`,
+  goenv tools default-tools list              # Show configured tools
+  goenv tools default-tools init              # Create default config file
+  goenv tools default-tools enable            # Enable auto-installation
+  goenv tools default-tools disable           # Disable auto-installation
+  goenv tools default-tools install 1.25.2    # Install tools for specific version`,
 }
 
 var defaultToolsListCmd = &cobra.Command{
@@ -104,7 +104,7 @@ func runDefaultToolsList(cmd *cobra.Command, args []string) error {
 	// Check if config exists
 	if utils.FileNotExists(configPath) {
 		fmt.Fprintln(cmd.OutOrStdout(), "No default tools configuration found.")
-		fmt.Fprintln(cmd.OutOrStdout(), "Run 'goenv tools default init' to create one.")
+		fmt.Fprintln(cmd.OutOrStdout(), "Run 'goenv tools default-tools init' to create one.")
 		return nil
 	}
 
@@ -248,7 +248,7 @@ func runInstallTools(cmd *cobra.Command, args []string) error {
 
 	if len(toolConfig.Tools) == 0 {
 		fmt.Fprintln(cmd.OutOrStdout(), "No tools configured to install.")
-		fmt.Fprintln(cmd.OutOrStdout(), "Run 'goenv tools default init' to create a default configuration.")
+		fmt.Fprintln(cmd.OutOrStdout(), "Run 'goenv tools default-tools init' to create a default configuration.")
 		return nil
 	}
 
@@ -307,7 +307,7 @@ func runVerify(cmd *cobra.Command, args []string) error {
 
 	if len(missing) > 0 {
 		fmt.Fprintln(cmd.OutOrStdout())
-		fmt.Fprintf(cmd.OutOrStdout(), "To install missing tools: goenv tools default install %s\n", goVersion)
+		fmt.Fprintf(cmd.OutOrStdout(), "To install missing tools: goenv tools default-tools install %s\n", goVersion)
 	}
 
 	return nil

cmd/tools/default_tools_test.go

@@ -27,7 +27,7 @@ func TestDefaultToolsList_NoConfig(t *testing.T) {
 
 	output := buf.String()
 	assert.Contains(t, output, "No default tools configuration found", "Expected 'No default tools configuration found' message %v", output)
-	assert.Contains(t, output, "goenv tools default init", "Expected init suggestion %v", output)
+	assert.Contains(t, output, "goenv tools default-tools init", "Expected init suggestion %v", output)
 }
 
 func TestDefaultToolsList_WithConfig(t *testing.T) {

cmd/tools/install_vscode.go

@@ -0,0 +1,107 @@
+package tools
+
+import (
+	"fmt"
+
+	"github.com/go-nv/goenv/internal/cmdutil"
+	"github.com/go-nv/goenv/internal/errors"
+	"github.com/go-nv/goenv/internal/tools"
+	"github.com/go-nv/goenv/internal/utils"
+	"github.com/spf13/cobra"
+)
+
+var installVSCodeCmd = &cobra.Command{
+	Use:   "install-vscode <version>",
+	Short: "Install VSCode Go extension tools for a Go version",
+	Long: `Installs all tools required by the VSCode Go extension for a specific Go version.
+
+This command installs the following tools as documented at:
+https://github.com/golang/vscode-go/wiki/tools
+
+Tools installed:
+  - gopls         (Go language server)
+  - dlv           (Delve debugger)
+  - vscgo         (VSCode Go utilities)
+  - goplay        (Go Playground support)
+  - gomodifytags  (Struct tag editor)
+  - impl          (Interface stub generator)
+  - gotests       (Test generator)
+  - staticcheck   (Static analysis tool)
+
+These tools provide the full IntelliSense, debugging, and code editing
+capabilities of the VSCode Go extension.
+
+Examples:
+  # Install VSCode tools for specific version
+  goenv tools install-vscode 1.25.2
+
+  # Install for current version
+  goenv tools install-vscode $(goenv version-name)
+
+  # Show what would be installed
+  goenv tools install-vscode 1.25.2 --dry-run`,
+	Args: cobra.ExactArgs(1),
+	RunE: runInstallVSCode,
+}
+
+var installVSCodeFlags struct {
+	dryRun  bool
+	verbose bool
+}
+
+func init() {
+	installVSCodeCmd.Flags().BoolVar(&installVSCodeFlags.dryRun, "dry-run", false, "Show what would be installed without installing")
+	installVSCodeCmd.Flags().BoolVarP(&installVSCodeFlags.verbose, "verbose", "v", false, "Show detailed installation output")
+}
+
+func runInstallVSCode(cmd *cobra.Command, args []string) error {
+	ctx := cmdutil.GetContexts(cmd)
+	cfg := ctx.Config
+	mgr := ctx.Manager
+	goVersion := args[0]
+
+	// Validate version is installed
+	if !mgr.IsVersionInstalled(goVersion) {
+		return fmt.Errorf("Go %s is not installed. Run 'goenv install %s' first", goVersion, goVersion)
+	}
+
+	versionPath := cfg.SafeResolvePath(goVersion)
+
+	fmt.Fprintf(cmd.OutOrStdout(), "Installing VSCode Go extension tools for Go %s...\n", goVersion)
+	fmt.Fprintln(cmd.OutOrStdout())
+
+	if installVSCodeFlags.dryRun {
+		fmt.Fprintf(cmd.OutOrStdout(), "%sDry run mode - no tools will be installed\n", utils.Emoji("ℹ️  "))
+		fmt.Fprintln(cmd.OutOrStdout())
+	}
+
+	// Build list of tools to install
+	toolPackages := make([]string, 0, len(tools.VSCodeTools))
+	for _, toolName := range tools.VSCodeTools {
+		pkg := tools.NormalizePackagePath(toolName)
+		toolPackages = append(toolPackages, pkg)
+	}
+
+	// Show what will be installed
+	fmt.Fprintln(cmd.OutOrStdout(), "Tools to install:")
+	for i, pkg := range toolPackages {
+		toolName := tools.ExtractToolName(pkg)
+		fmt.Fprintf(cmd.OutOrStdout(), "  %d. %-15s %s\n", i+1, toolName, pkg)
+	}
+	fmt.Fprintln(cmd.OutOrStdout())
+
+	if installVSCodeFlags.dryRun {
+		return nil
+	}
+
+	// Install VSCode tools
+	if err := tools.InstallVSCodeToolsForVersion(goVersion, cfg.Root, versionPath, installVSCodeFlags.verbose); err != nil {
+		return errors.FailedTo("install VSCode tools", err)
+	}
+
+	fmt.Fprintln(cmd.OutOrStdout())
+	fmt.Fprintf(cmd.OutOrStdout(), "%sVSCode tools installed successfully\n", utils.Emoji("✅ "))
+	fmt.Fprintf(cmd.OutOrStdout(), "%sRun 'goenv rehash' to make tools available as shims\n", utils.Emoji("💡 "))
+
+	return nil
+}

cmd/tools/tools.go

@@ -54,11 +54,12 @@ func init() {
 	cmdpkg.RootCmd.AddCommand(toolsCmd)
 
 	// Add subcommands (each defined in their own file)
-	toolsCmd.AddCommand(installToolsCmd) // from install_tools.go
-	toolsCmd.AddCommand(listToolsCmd)    // from list_tools.go
-	toolsCmd.AddCommand(updateToolsCmd)  // from update_tools.go
-	toolsCmd.AddCommand(syncToolsCmd)    // from sync_tools.go
-	toolsCmd.AddCommand(defaultToolsCmd) // from default_tools.go
+	toolsCmd.AddCommand(installToolsCmd)  // from install_tools.go
+	toolsCmd.AddCommand(installVSCodeCmd) // from install_vscode.go
+	toolsCmd.AddCommand(listToolsCmd)     // from list_tools.go
+	toolsCmd.AddCommand(updateToolsCmd)   // from update_tools.go
+	toolsCmd.AddCommand(syncToolsCmd)     // from sync_tools.go
+	toolsCmd.AddCommand(defaultToolsCmd)  // from default_tools.go
 
 	// Add uninstall command
 	cfg := config.Load()

internal/errors/goenv.go

@@ -30,6 +30,14 @@ func VersionNotInstalledDetailed(version, source string, installedVersions []str
 
 	sb.WriteString("\n")
 
+	// Add context for go.mod files (Go 1.26+ behavior)
+	if source != "" && strings.Contains(source, "go.mod") {
+		sb.WriteString("Note: Starting in Go 1.26, 'go mod init' defaults to setting the go\n")
+		sb.WriteString("directive to one version behind for backward compatibility.\n")
+		sb.WriteString("This is normal and expected behavior.\n")
+		sb.WriteString("\n")
+	}
+
 	// Suggest installation
 	sb.WriteString("To install this version:\n")
 	sb.WriteString(fmt.Sprintf("  goenv install %s\n", version))