feat(reshim): add detailed output with per-runtime progress

- Show 'Regenerating shims for <Runtime>...' for each runtime
- Display summary table with runtime names and their shims
- Show total count of shims and runtimes created
- Add RehashWithCallback for progress reporting

Author: CalvinAllen

src/cmd/reshim.go

@@ -1,8 +1,14 @@
 package cmd
 
 import (
+	"fmt"
+	"sort"
+	"strings"
+
 	"github.com/dtvem/dtvem/src/internal/config"
+	"github.com/dtvem/dtvem/src/internal/runtime"
 	"github.com/dtvem/dtvem/src/internal/shim"
+	"github.com/dtvem/dtvem/src/internal/tui"
 	"github.com/dtvem/dtvem/src/internal/ui"
 	"github.com/spf13/cobra"
 )
@@ -18,8 +24,6 @@ Run this command after installing new versions or if shims become corrupted.
 Example:
   dtvem reshim`,
 	Run: func(cmd *cobra.Command, args []string) {
-		ui.Header("Regenerating shims...")
-
 		// Ensure directories exist
 		if err := config.EnsureDirectories(); err != nil {
 			ui.Error("Failed to create directories: %v", err)
@@ -34,17 +38,59 @@ Example:
 			return
 		}
 
-		// Regenerate shims with spinner
-		spinner := ui.NewSpinner("Regenerating shims...")
-		spinner.Start()
+		// Collect display names as we process
+		displayNames := make(map[string]string)
 
-		if err := manager.Rehash(); err != nil {
-			spinner.Error("Failed to regenerate shims")
+		// Regenerate shims with per-runtime progress
+		result, err := manager.RehashWithCallback(func(runtimeName, displayName string) {
+			displayNames[runtimeName] = displayName
+			ui.Info("Regenerating shims for %s...", displayName)
+		})
+
+		if err != nil {
+			fmt.Println()
 			ui.Error("%v", err)
 			return
 		}
 
-		spinner.Success("Shims regenerated successfully")
+		fmt.Println()
+
+		// Display results in a table
+		table := tui.NewTable("Runtime", "Shims")
+		table.SetTitle("Shims Created")
+
+		// Sort runtime names for consistent output
+		runtimeNames := make([]string, 0, len(result.ShimsByRuntime))
+		for name := range result.ShimsByRuntime {
+			runtimeNames = append(runtimeNames, name)
+		}
+		sort.Strings(runtimeNames)
+
+		for _, runtimeName := range runtimeNames {
+			shims := result.ShimsByRuntime[runtimeName]
+			sort.Strings(shims)
+
+			// Get display name from provider
+			displayName := runtimeName
+			if provider, err := runtime.Get(runtimeName); err == nil {
+				displayName = provider.DisplayName()
+			} else if len(displayName) > 0 {
+				// Capitalize first letter as fallback
+				displayName = strings.ToUpper(displayName[:1]) + displayName[1:]
+			}
+
+			// Format shims list (truncate if too long)
+			shimList := strings.Join(shims, ", ")
+			if len(shimList) > 60 {
+				shimList = shimList[:57] + "..."
+			}
+
+			table.AddRow(displayName, shimList)
+		}
+
+		fmt.Println(table.Render())
+		fmt.Println()
+		ui.Success("Created %d shims for %d runtime(s)", result.TotalShims, len(result.ShimsByRuntime))
 	},
 }
 

src/cmd/uninstall.go

@@ -108,7 +108,7 @@ Examples:
 			shimSpinner.Warning("Could not regenerate shims")
 			ui.Warning("You may need to run 'dtvem reshim' manually")
 		} else {
-			if err := manager.Rehash(); err != nil {
+			if _, err := manager.Rehash(); err != nil {
 				shimSpinner.Warning("Could not regenerate shims")
 				ui.Warning("You may need to run 'dtvem reshim' manually")
 			} else {

src/internal/shim/manager.go

@@ -130,22 +130,42 @@ func (m *Manager) ListShims() ([]string, error) {
 	return shims, nil
 }
 
-// Rehash regenerates all shims by scanning installed versions
-func (m *Manager) Rehash() error {
+// RehashResult contains the results of a reshim operation
+type RehashResult struct {
+	// ShimsByRuntime maps runtime names to their shim names
+	ShimsByRuntime map[string][]string
+	// TotalShims is the total number of shims created
+	TotalShims int
+}
+
+// RuntimeShimInfo contains shim information for a single runtime
+type RuntimeShimInfo struct {
+	RuntimeName string
+	Shims       []string
+}
+
+// RehashCallback is called before processing each runtime
+// runtimeName is the internal name, displayName is the user-friendly name
+type RehashCallback func(runtimeName, displayName string)
+
+// RehashWithCallback regenerates all shims, calling the callback before each runtime
+func (m *Manager) RehashWithCallback(callback RehashCallback) (*RehashResult, error) {
 	paths := config.DefaultPaths()
 	versionsDir := paths.Versions
 
 	// Read all runtime directories
 	entries, err := os.ReadDir(versionsDir)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return fmt.Errorf("no versions directory found - no runtimes installed yet")
+			return nil, fmt.Errorf("no versions directory found - no runtimes installed yet")
 		}
-		return fmt.Errorf("failed to read versions directory: %w", err)
+		return nil, fmt.Errorf("failed to read versions directory: %w", err)
 	}
 
 	// Collect shim-to-runtime mappings (shim name -> runtime name)
 	shimMap := make(ShimMap)
+	// Also track shims by runtime for reporting
+	shimsByRuntime := make(map[string][]string)
 
 	for _, entry := range entries {
 		if !entry.IsDir() {
@@ -161,6 +181,29 @@ func (m *Manager) Rehash() error {
 			continue
 		}
 
+		// Skip if no versions installed
+		hasVersions := false
+		for _, ve := range versionEntries {
+			if ve.IsDir() {
+				hasVersions = true
+				break
+			}
+		}
+		if !hasVersions {
+			continue
+		}
+
+		// Get display name from provider
+		displayName := runtimeName
+		if provider, err := runtimepkg.Get(runtimeName); err == nil {
+			displayName = provider.DisplayName()
+		}
+
+		// Call the callback before processing this runtime
+		if callback != nil {
+			callback(runtimeName, displayName)
+		}
+
 		// For each installed version, scan for executables
 		for _, versionEntry := range versionEntries {
 			if !versionEntry.IsDir() {
@@ -173,13 +216,15 @@ func (m *Manager) Rehash() error {
 			coreShims := RuntimeShims(runtimeName)
 			for _, shimName := range coreShims {
 				shimMap[shimName] = runtimeName
+				shimsByRuntime[runtimeName] = appendUnique(shimsByRuntime[runtimeName], shimName)
 			}
 
 			// Then, scan bin directory for globally installed packages
 			binDir := filepath.Join(versionDir, "bin")
 			if execs, err := findExecutables(binDir); err == nil {
 				for _, exec := range execs {
 					shimMap[exec] = runtimeName
+					shimsByRuntime[runtimeName] = appendUnique(shimsByRuntime[runtimeName], exec)
 				}
 			}
 
@@ -189,36 +234,56 @@ func (m *Manager) Rehash() error {
 				if execs, err := findExecutables(versionDir); err == nil {
 					for _, exec := range execs {
 						shimMap[exec] = runtimeName
+						shimsByRuntime[runtimeName] = appendUnique(shimsByRuntime[runtimeName], exec)
 					}
 				}
 				// Check Scripts directory for Python pip packages
 				scriptsDir := filepath.Join(versionDir, "Scripts")
 				if execs, err := findExecutables(scriptsDir); err == nil {
 					for _, exec := range execs {
 						shimMap[exec] = runtimeName
+						shimsByRuntime[runtimeName] = appendUnique(shimsByRuntime[runtimeName], exec)
 					}
 				}
 			}
 		}
 	}
 
 	if len(shimMap) == 0 {
-		return fmt.Errorf("no runtimes installed - nothing to reshim")
+		return nil, fmt.Errorf("no runtimes installed - nothing to reshim")
 	}
 
 	// Save the shim map cache
 	if err := SaveShimMap(shimMap); err != nil {
-		return fmt.Errorf("failed to save shim map cache: %w", err)
+		return nil, fmt.Errorf("failed to save shim map cache: %w", err)
 	}
 
 	// Create all shims
 	for shimName := range shimMap {
 		if err := m.CreateShim(shimName); err != nil {
-			return err
+			return nil, err
 		}
 	}
 
-	return nil
+	return &RehashResult{
+		ShimsByRuntime: shimsByRuntime,
+		TotalShims:     len(shimMap),
+	}, nil
+}
+
+// Rehash regenerates all shims by scanning installed versions (no progress callback)
+func (m *Manager) Rehash() (*RehashResult, error) {
+	return m.RehashWithCallback(nil)
+}
+
+// appendUnique appends a string to a slice only if it's not already present
+func appendUnique(slice []string, s string) []string {
+	for _, existing := range slice {
+		if existing == s {
+			return slice
+		}
+	}
+	return append(slice, s)
 }
 
 // copyFile copies a file from src to dst