perf(shim): add shim-to-runtime mapping cache for O(1) lookups

Add a persistent shim-to-runtime mapping cache that enables O(1) lookups
and fixes dynamic shim resolution for globally installed packages.

Changes:
- Add cache directory to Paths struct (~/.dtvem/cache/)
- Generate shim-map.json during reshim operations
- Load cache in mapShimToRuntime() with sync.Once for efficiency
- Fall back to provider-based lookup if cache is missing

This fixes shims for dynamically installed packages (tsc, eslint, black,
pytest, etc.) which previously failed with "runtime provider not found"
because the fallback returned the shim name as the runtime name.

Closes #93

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: CalvinAllen

src/cmd/shim/main.go

@@ -13,6 +13,7 @@ import (
 	"github.com/dtvem/dtvem/src/internal/config"
 	"github.com/dtvem/dtvem/src/internal/constants"
 	"github.com/dtvem/dtvem/src/internal/runtime"
+	"github.com/dtvem/dtvem/src/internal/shim"
 	"github.com/dtvem/dtvem/src/internal/ui"
 
 	// Import runtime providers to register them
@@ -193,26 +194,33 @@ func getShimName() string {
 }
 
 // mapShimToRuntime maps a shim name to its runtime
-// For example: python3 -> python, pip -> python, npm -> node
-// This queries all registered providers for their shims, eliminating the need
-// for a central hardcoded mapping.
+// For example: python3 -> python, pip -> python, npm -> node, tsc -> node
+// First checks the shim map cache (generated by reshim), then falls back
+// to querying registered providers.
 func mapShimToRuntime(shimName string) string {
+	// First, try the shim map cache for O(1) lookup
+	// This handles both core shims and dynamically installed packages (tsc, eslint, black, etc.)
+	if runtimeName, ok := shim.LookupRuntime(shimName); ok {
+		return runtimeName
+	}
+
+	// Fall back to provider-based lookup if cache is missing or doesn't have the shim
 	// Get all registered providers (using ShimProvider interface)
 	providers := runtime.GetAllShimProviders()
 
 	// Check each provider's shims for an exact match first
 	for _, provider := range providers {
-		for _, shim := range provider.Shims() {
-			if shim == shimName {
+		for _, s := range provider.Shims() {
+			if s == shimName {
 				return provider.Name()
 			}
 		}
 	}
 
 	// Check for prefix match (e.g., python3 -> python)
 	for _, provider := range providers {
-		for _, shim := range provider.Shims() {
-			if strings.HasPrefix(shimName, shim) {
+		for _, s := range provider.Shims() {
+			if strings.HasPrefix(shimName, s) {
 				return provider.Name()
 			}
 		}

src/internal/config/paths.go

@@ -16,6 +16,7 @@ type Paths struct {
 	Shims    string // Shims directory (~/.dtvem/shims)
 	Versions string // Versions directory (~/.dtvem/versions)
 	Config   string // Config directory (~/.dtvem/config)
+	Cache    string // Cache directory (~/.dtvem/cache)
 }
 
 var (
@@ -40,6 +41,7 @@ func initPaths() *Paths {
 		Shims:    filepath.Join(root, "shims"),
 		Versions: filepath.Join(root, "versions"),
 		Config:   filepath.Join(root, "config"),
+		Cache:    filepath.Join(root, "cache"),
 	}
 }
 
@@ -90,6 +92,7 @@ func EnsureDirectories() error {
 		paths.Shims,
 		paths.Versions,
 		paths.Config,
+		paths.Cache,
 	}
 
 	for _, dir := range dirs {
@@ -120,3 +123,19 @@ const LocalConfigDirName = ".dtvem"
 
 // RuntimesFileName is the name of the runtimes configuration file
 const RuntimesFileName = "runtimes.json"
+
+// ShimMapFileName is the name of the shim-to-runtime mapping cache file
+const ShimMapFileName = "shim-map.json"
+
+// ShimMapPath returns the path to the shim-to-runtime mapping cache file
+func ShimMapPath() string {
+	paths := DefaultPaths()
+	return filepath.Join(paths.Cache, ShimMapFileName)
+}
+
+// ResetPathsCache resets the cached paths, forcing reinitialization on next access.
+// This is primarily useful for testing.
+func ResetPathsCache() {
+	pathsOnce = sync.Once{}
+	defaultPaths = nil
+}

src/internal/shim/cache.go

@@ -0,0 +1,87 @@
+// Package shim manages shim executables that intercept runtime commands
+package shim
+
+import (
+	"encoding/json"
+	"os"
+	"sync"
+
+	"github.com/dtvem/dtvem/src/internal/config"
+)
+
+// ShimMap represents the shim-to-runtime mapping cache
+// The map key is the shim name (e.g., "tsc", "npm", "black")
+// The map value is the runtime name (e.g., "node", "python")
+type ShimMap map[string]string
+
+var (
+	shimMapCache     ShimMap
+	shimMapCacheOnce sync.Once
+	shimMapCacheErr  error
+)
+
+// LoadShimMap loads the shim-to-runtime mapping from the cache file.
+// It uses sync.Once to ensure the cache is only loaded once per process.
+// Returns the cached map and any error that occurred during loading.
+func LoadShimMap() (ShimMap, error) {
+	shimMapCacheOnce.Do(func() {
+		shimMapCache, shimMapCacheErr = loadShimMapFromDisk()
+	})
+	return shimMapCache, shimMapCacheErr
+}
+
+// loadShimMapFromDisk reads the shim map cache file from disk
+func loadShimMapFromDisk() (ShimMap, error) {
+	cachePath := config.ShimMapPath()
+
+	data, err := os.ReadFile(cachePath)
+	if err != nil {
+		return nil, err
+	}
+
+	var shimMap ShimMap
+	if err := json.Unmarshal(data, &shimMap); err != nil {
+		return nil, err
+	}
+
+	return shimMap, nil
+}
+
+// SaveShimMap writes the shim-to-runtime mapping to the cache file.
+// This should be called during reshim operations.
+func SaveShimMap(shimMap ShimMap) error {
+	// Ensure cache directory exists
+	paths := config.DefaultPaths()
+	if err := os.MkdirAll(paths.Cache, 0755); err != nil {
+		return err
+	}
+
+	cachePath := config.ShimMapPath()
+
+	data, err := json.MarshalIndent(shimMap, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(cachePath, data, 0644)
+}
+
+// LookupRuntime looks up the runtime for a given shim name using the cache.
+// Returns the runtime name and true if found, or empty string and false if not.
+func LookupRuntime(shimName string) (string, bool) {
+	shimMap, err := LoadShimMap()
+	if err != nil {
+		return "", false
+	}
+
+	runtime, ok := shimMap[shimName]
+	return runtime, ok
+}
+
+// ResetShimMapCache resets the cached shim map, forcing a reload on next access.
+// This is primarily useful for testing.
+func ResetShimMapCache() {
+	shimMapCacheOnce = sync.Once{}
+	shimMapCache = nil
+	shimMapCacheErr = nil
+}