Merge pull request #5 from stepbeta/feat/support-install-latest

feat: add support for installing "latest" version

Author: stepbeta

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "go.coverOnSave": true,
+    "go.coverageDecorator": {
+        "type": "gutter",
+        "coveredGutterStyle": "blockgreen",
+        "uncoveredGutterStyle": "blockred"
+    }
+}

AGENTS.md

@@ -0,0 +1,51 @@
+# Copilot Instructions
+
+You are an expert Go developer working on this CLI application built with Cobra.
+
+## Project Overview
+
+**vrsr** (Version Selector Runner) is a CLI tool for managing multiple versions of various command-line tools. It allows users to easily install, list, and switch between different versions of tools like `kubectl`, `helm`, `kind`, `talosctl`, `cilium`, and `hubble`. The tool downloads binaries from GitHub releases and manages them in a configurable storage path.
+
+## Project Structure
+
+- `cmd/` - Cobra commands (root.go, version.go, docs.go)
+- `internal/cli/` - Command implementations organized by subcommand
+- `internal/cli/tools/` - Tool-specific subcommands (kubectl, helm, kind, etc.)
+- `internal/cli/common/` - Shared command utilities (install, list, use, etc.)
+- `internal/utils/` - Utility functions (cache, binary management)
+- `internal/github/` - GitHub API helpers
+
+## Code Style
+
+- Use `cobra.Command` for CLI commands
+- Use `viper` for configuration management
+- Use environment variable prefix `VRSR_` (e.g., `VRSR_BIN_PATH`)
+- Follow standard Go conventions: `camelCase` for variables, `PascalCase` for exported functions/types
+- Use meaningful error messages and wrap errors with `fmt.Errorf("context: %w", err)`
+- Use the `command` pattern from `internal/cli/common/command.go` for consistent subcommand structure
+- Always format and lint code after a modification.
+
+## Testing
+
+- Write unit tests with the `_test.go` suffix in the same package
+- Use table-driven tests where appropriate
+
+## Commands
+
+- Run the CLI: `go run main.go`
+- Run tests: `go test ./...`
+- Build: `go build -o vrsr`
+- Format code: `go fmt -w -s .`
+- Lint code: `golangci-lint run`
+- Add a new tool subcommand: Follow the pattern in `internal/cli/tools/`
+
+## Constraints
+
+- Never execute destructive commands (rm -rf, dd, mkfs, etc.) unless the user asks explicitly
+- If the user asks for a destructive command, always ask for confirmation before executing
+- Never modify or delete files outside the project directory without user consent
+- Always validate potentially destructive operations with the user before proceeding
+- Never run commands that could affect the host system (systemd operations, disk operations, etc.)
+- When in doubt, ask the user to confirm before taking any action that modifies system state
+- Do not interact with Git or GitHub repositories without explicit user instructions
+- Always prioritize user safety and data integrity in all operations

internal/cli/common/install.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -43,6 +44,16 @@ func newInstallCommand(tool string, repoConf github.RepoConfDef, installType Ins
 
 // install downloads and installs the specified version of the tool from GitHub releases
 func install(cmd *cobra.Command, vrs, tool string, repoConf github.RepoConfDef, installType InstallCmdType, skipMsg bool) error {
+	if strings.ToLower(vrs) == "latest" {
+		ghc := github.New(nil)
+		latestVrs, err := getLatestVersion(tool, repoConf, ghc)
+		if err != nil {
+			return fmt.Errorf("failed to get latest version: %w", err)
+		}
+		vrs = latestVrs
+		cmd.Printf("Resolved 'latest' to version %s\n", vrs)
+	}
+
 	if utils.IsToolInUse(tool, vrs) {
 		cmd.Printf("%s version %s is already installed and in use. Nothing to do\n", tool, vrs)
 		return nil
@@ -111,3 +122,21 @@ func useOnInstallFn(cmd *cobra.Command, vrs, tool string) error {
 	}
 	return nil
 }
+
+func getLatestVersion(tool string, repoConf github.RepoConfDef, ghc github.GithubHelper) (string, error) {
+	releasesData, err := ghc.FetchAllReleases(tool, github.FetchOptions{
+		IncludeDevel: false,
+		Limit:        0,
+		Force:        true,
+		RepoConf:     repoConf,
+	})
+	if err != nil {
+		return "", err
+	}
+	versions := utils.SemverFromReleases(releasesData.Releases, false)
+	if len(versions) == 0 {
+		return "", fmt.Errorf("no versions found for %s", tool)
+	}
+	latest := versions[len(versions)-1]
+	return latest.Original(), nil
+}

internal/cli/common/install_test.go

@@ -1,15 +1,106 @@
 package common
 
 import (
+	"context"
+	"io"
+	"net/http"
 	"os"
 	"path/filepath"
 	"testing"
 
+	"github.com/google/go-github/v78/github"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"github.com/stepbeta/vrsr/internal/github"
+	vrsrgithub "github.com/stepbeta/vrsr/internal/github"
 )
 
+type mockReposService struct {
+	releases []*github.RepositoryRelease
+}
+
+func (m *mockReposService) ListReleases(ctx context.Context, owner, repo string, opts *github.ListOptions) ([]*github.RepositoryRelease, *github.Response, error) {
+	return m.releases, &github.Response{}, nil
+}
+
+func (m *mockReposService) GetReleaseByTag(ctx context.Context, owner, repo, tag string) (*github.RepositoryRelease, *github.Response, error) {
+	return nil, &github.Response{}, nil
+}
+
+func (m *mockReposService) DownloadReleaseAsset(ctx context.Context, owner, repo string, assetID int64, httpClient *http.Client) (io.ReadCloser, string, error) {
+	return nil, "", nil
+}
+
+func TestGetLatestVersion(t *testing.T) {
+	tests := []struct {
+		name           string
+		releases       []*github.RepositoryRelease
+		expectedLatest string
+		expectedError  bool
+	}{
+		{
+			name: "returns highest semver",
+			releases: []*github.RepositoryRelease{
+				{TagName: github.Ptr("v1.0.0")},
+				{TagName: github.Ptr("v1.2.3")},
+				{TagName: github.Ptr("v1.1.0")},
+			},
+			expectedLatest: "v1.2.3",
+			expectedError:  false,
+		},
+		{
+			name: "handles complex semver versions",
+			releases: []*github.RepositoryRelease{
+				{TagName: github.Ptr("v1.0.0")},
+				{TagName: github.Ptr("v2.0.0-alpha")},
+				{TagName: github.Ptr("v2.0.0-beta")},
+				{TagName: github.Ptr("v2.0.0-rc.1")},
+				{TagName: github.Ptr("v2.0.0")},
+			},
+			expectedLatest: "v2.0.0",
+			expectedError:  false,
+		},
+		{
+			name:           "returns error when no releases",
+			releases:       []*github.RepositoryRelease{},
+			expectedLatest: "",
+			expectedError:  true,
+		},
+		{
+			name: "handles non-semver tags gracefully",
+			releases: []*github.RepositoryRelease{
+				{TagName: github.Ptr("not-a-version")},
+				{TagName: github.Ptr("v1.0.0")},
+			},
+			expectedLatest: "v1.0.0",
+			expectedError:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockRepos := &mockReposService{releases: tt.releases}
+			mockGh := vrsrgithub.GithubHelper{
+				Repos: mockRepos,
+			}
+
+			result, err := getLatestVersion("testtool", vrsrgithub.RepoConfDef{}, mockGh)
+
+			if tt.expectedError {
+				if err == nil {
+					t.Errorf("expected error, got nil")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("unexpected error: %v", err)
+				}
+				if result != tt.expectedLatest {
+					t.Errorf("expected %s, got %s", tt.expectedLatest, result)
+				}
+			}
+		})
+	}
+}
+
 func TestInstallCommands_EarlyReturnWhenInUseOrInstalled(t *testing.T) {
 	// setup temp dirs
 	td := t.TempDir()
@@ -42,7 +133,7 @@ func TestInstallCommands_EarlyReturnWhenInUseOrInstalled(t *testing.T) {
 	viper.Set("bin-path", binPath)
 
 	// calling install Github should return early (tool already in use)
-	if err := install(&cobra.Command{}, "1.2.3", "mytool", github.RepoConfDef{}, InstallGitHubCmd, false); err != nil {
+	if err := install(&cobra.Command{}, "1.2.3", "mytool", vrsrgithub.RepoConfDef{}, InstallGitHubCmd, false); err != nil {
 		t.Fatalf("install Github expected nil error when tool in use, got: %v", err)
 	}
 
@@ -52,7 +143,7 @@ func TestInstallCommands_EarlyReturnWhenInUseOrInstalled(t *testing.T) {
 	}
 
 	// calling install Download should return early (tool already installed)
-	if err := install(&cobra.Command{}, "1.2.3", "mytool", github.RepoConfDef{}, InstallDownloadCmd, false); err != nil {
+	if err := install(&cobra.Command{}, "1.2.3", "mytool", vrsrgithub.RepoConfDef{}, InstallDownloadCmd, false); err != nil {
 		t.Fatalf("install Download expected nil error when tool installed, got: %v", err)
 	}
 }

internal/cli/common/list.go

@@ -11,9 +11,10 @@ import (
 // newGithubListCommand creates a new 'list' command for the specified tool
 func newListCommand(tool string) *cobra.Command {
 	return &cobra.Command{
-		Use:   "list",
-		Short: fmt.Sprintf("List all installed %s versions", tool),
-		Long:  fmt.Sprintf(`Lists all the %s versions that are currently installed on the system.`, tool),
+		Use:     "list",
+		Aliases: []string{"ls"},
+		Short:   fmt.Sprintf("List all installed %s versions", tool),
+		Long:    fmt.Sprintf(`Lists all the %s versions that are currently installed on the system.`, tool),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return list(cmd, tool)
 		},

internal/cli/common/listRemote.go

@@ -21,8 +21,9 @@ var (
 // newGithubListRemoteCommand creates a new 'list-remote' command for the specified tool
 func newGithubListRemoteCommand(tool string, repoConf github.RepoConfDef) *cobra.Command {
 	listRemoteCmd := &cobra.Command{
-		Use:   "list-remote",
-		Short: fmt.Sprintf("List all remote %s versions from GitHub (sorted by semver)", tool),
+		Use:     "list-remote",
+		Aliases: []string{"ls-remote"},
+		Short:   fmt.Sprintf("List all remote %s versions from GitHub (sorted by semver)", tool),
 		Long: fmt.Sprintf("Lists all the remote %s versions available as GitHub releases (sorted by semver).\n\n"+
 			"In the list the versions currently installed are marked with a '+' symbol, while the version currently in use is marked with a '*' symbol.\n\n"+
 			"Note: By default pre-release versions (alpha, beta, rc) are hidden. Use '--devel' to include them", tool),