feat(cli): select latest local release

Support set latest by choosing the highest stable semantic version
already installed locally. Ignore nightly and prerelease directories, and
keep selection free of network or installation side effects. Document the
separate current and set commands.

Refs: #12

Author: piraz

README.md

@@ -126,20 +126,31 @@ nvimim upgrade -y
 
 ---
 
-### `nvimim current` — Show or switch the active version
+### `nvimim current` — Show the active version
 
-Show which version is currently active:
+Displays the version currently selected as active. This command is
+read-only:
 
 ```bash
 nvimim current
 
 * 0.11.5
 ```
 
-Switch to a different installed version:
+### `nvimim set <version>` — Select an installed version
+
+Selects a version that is already installed locally. It never downloads or
+installs a release:
+
+```bash
+nvimim set 0.11.3
+```
+
+Use `latest` to select the highest stable version installed locally. Nightly
+and prerelease directories are ignored:
 
 ```bash
-nvimim current 0.11.3
+nvimim set latest
 ```
 
 ---

internal/cli/command.go

@@ -63,15 +63,19 @@ func (cmd *SetCommand) Execute(args []string) error {
 		return fmt.Errorf("nvim path does not exist: %s", cmd.appOpts.Path)
 	}
 
-	release := args[0]
-	if release == "latest" {
-		return fmt.Errorf("latest release selection is not available yet")
+	selectedRelease := args[0]
+	var err error
+	if selectedRelease == "latest" {
+		selectedRelease, err = release.LatestInstalledStable(cmd.appOpts.Path)
+		if err != nil {
+			return err
+		}
 	}
-	if !pathx.Exists(filepath.Join(cmd.appOpts.Path, release)) {
-		return fmt.Errorf("the release %s is not installed", release)
+	if !pathx.Exists(filepath.Join(cmd.appOpts.Path, selectedRelease)) {
+		return fmt.Errorf("the release %s is not installed", selectedRelease)
 	}
 
-	return setCurrentRelease(cmd.appOpts.Path, release)
+	return setCurrentRelease(cmd.appOpts.Path, selectedRelease)
 }
 
 func (cmd *SetCommand) SetAppOptions(opts *config.AppOptions) {

internal/cli/current_test.go

@@ -9,43 +9,71 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	explicitVersion    = "0.12.0"
+	olderStableVersion = "0.11.5"
+	prereleaseVersion  = "0.13.0-rc1"
+)
+
 func TestSetCommandSelectsInstalledRelease(t *testing.T) {
 	installPath := t.TempDir()
-	releasePath := filepath.Join(installPath, "0.12.0")
-	otherReleasePath := filepath.Join(installPath, "0.11.5")
+	releasePath := filepath.Join(installPath, explicitVersion)
+	otherReleasePath := filepath.Join(installPath, olderStableVersion)
 	require.NoError(t, os.Mkdir(releasePath, 0o755))
 	require.NoError(t, os.Mkdir(otherReleasePath, 0o755))
 
 	cmd := &SetCommand{}
 	cmd.SetAppOptions(&config.AppOptions{Path: installPath})
 
-	require.NoError(t, cmd.Execute([]string{"0.12.0"}))
+	require.NoError(t, cmd.Execute([]string{explicitVersion}))
 
 	current, err := os.Readlink(filepath.Join(installPath, "current"))
 	require.NoError(t, err)
 	require.Equal(t, releasePath, current)
 }
 
+func TestSetCommandLatestSelectsHighestStableRelease(t *testing.T) {
+	installPath := t.TempDir()
+	for _, name := range []string{
+		olderStableVersion,
+		explicitVersion,
+		"nightly",
+		prereleaseVersion,
+	} {
+		require.NoError(t, os.Mkdir(filepath.Join(installPath, name), 0o755))
+	}
+
+	cmd := &SetCommand{}
+	cmd.SetAppOptions(&config.AppOptions{Path: installPath})
+
+	require.NoError(t, cmd.Execute([]string{"latest"}))
+
+	current, err := os.Readlink(filepath.Join(installPath, "current"))
+	require.NoError(t, err)
+	require.Equal(t, filepath.Join(installPath, explicitVersion), current)
+}
+
 func TestSetCommandOnlySelectsInstalledReleases(t *testing.T) {
 	installPath := t.TempDir()
 	cmd := &SetCommand{}
 	cmd.SetAppOptions(&config.AppOptions{Path: installPath})
 
-	err := cmd.Execute([]string{"0.12.0"})
-	require.EqualError(t, err, "the release 0.12.0 is not installed")
+	err := cmd.Execute([]string{explicitVersion})
+	require.EqualError(t, err,
+		"the release "+explicitVersion+" is not installed")
 }
 
 func TestCurrentCommandIsReadOnly(t *testing.T) {
 	installPath := t.TempDir()
-	releasePath := filepath.Join(installPath, "0.12.0")
+	releasePath := filepath.Join(installPath, explicitVersion)
 	require.NoError(t, os.Mkdir(releasePath, 0o755))
 	require.NoError(t, os.Symlink(releasePath,
 		filepath.Join(installPath, "current")))
 
 	cmd := &CurrentCommand{}
 	cmd.SetAppOptions(&config.AppOptions{Path: installPath})
 
-	err := cmd.Execute([]string{"0.12.0"})
+	err := cmd.Execute([]string{explicitVersion})
 	require.EqualError(t, err,
 		"current does not accept arguments; use 'set <release>'")
 

internal/release/info.go

@@ -3,6 +3,7 @@ package release
 import (
 	"encoding/json"
 	"fmt"
+	"os"
 	"path/filepath"
 	"regexp"
 	"strconv"
@@ -45,6 +46,56 @@ func (rs *Releases) Installed(path string) []Info {
 	return installed
 }
 
+// LatestInstalledStable returns the highest stable semantic version found in
+// the installation path. Nightly, prerelease, and non-version entries are
+// ignored.
+func LatestInstalledStable(path string) (string, error) {
+	entries, err := os.ReadDir(path)
+	if err != nil {
+		return "", fmt.Errorf("failed to read install path: %w", err)
+	}
+
+	latest := ""
+	for _, entry := range entries {
+		if !entry.IsDir() || !isStableVersion(entry.Name()) {
+			continue
+		}
+		if latest == "" || versionLess(latest, entry.Name()) {
+			latest = entry.Name()
+		}
+	}
+	if latest == "" {
+		return "", fmt.Errorf("no stable releases installed")
+	}
+	return latest, nil
+}
+
+func isStableVersion(version string) bool {
+	parts := strings.Split(version, ".")
+	if len(parts) != 3 {
+		return false
+	}
+	for _, part := range parts {
+		if _, err := strconv.Atoi(part); err != nil {
+			return false
+		}
+	}
+	return true
+}
+
+func versionLess(left, right string) bool {
+	leftParts := strings.Split(left, ".")
+	rightParts := strings.Split(right, ".")
+	for i := range leftParts {
+		leftPart, _ := strconv.Atoi(leftParts[i])
+		rightPart, _ := strconv.Atoi(rightParts[i])
+		if leftPart != rightPart {
+			return leftPart < rightPart
+		}
+	}
+	return false
+}
+
 // Available returns a list of releases that are not present in the installed
 // releases.
 func (rs *Releases) Available(installed []Info) []Info {