refactor(dotfiles): improve app handling with typed names and dynamic filtering

- Add DotfileAppName type with enum-like constants for all available apps
- Create GetAllAppsMap() function to centralize app handler initialization
- Update dotfiles_pull.go to support filtering by specific apps parameter
- Use typed app names instead of string literals for better type safety
- Improve code maintainability and reduce duplication in app management

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

Co-Authored-By: Claude <noreply@anthropic.com>

Author: AnnatarHe

commands/dotfiles_pull.go

@@ -56,20 +56,21 @@ func pullDotfiles(c *cli.Context) error {
 		return nil
 	}
 
-	// Initialize all available app handlers
-	allApps := map[string]model.DotfileApp{
-		"nvim":       model.NewNvimApp(),
-		"fish":       model.NewFishApp(),
-		"git":        model.NewGitApp(),
-		"zsh":        model.NewZshApp(),
-		"bash":       model.NewBashApp(),
-		"ghostty":    model.NewGhosttyApp(),
-		"claude":     model.NewClaudeApp(),
-		"starship":   model.NewStarshipApp(),
-		"npm":        model.NewNpmApp(),
-		"ssh":        model.NewSshApp(),
-		"kitty":      model.NewKittyApp(),
-		"kubernetes": model.NewKubernetesApp(),
+	// Initialize app handlers based on apps parameter
+	var allApps map[model.DotfileAppName]model.DotfileApp
+	if len(apps) == 0 {
+		// If no specific apps specified, use all available apps
+		allApps = model.GetAllAppsMap()
+	} else {
+		// Only include specified apps
+		allAppsMap := model.GetAllAppsMap()
+		allApps = make(map[model.DotfileAppName]model.DotfileApp)
+		for _, appNameStr := range apps {
+			appName := model.DotfileAppName(appNameStr)
+			if appHandler, exists := allAppsMap[appName]; exists {
+				allApps[appName] = appHandler
+			}
+		}
 	}
 
 	// Process fetched dotfiles
@@ -78,7 +79,8 @@ func pullDotfiles(c *cli.Context) error {
 	totalFailed := 0
 
 	for _, appData := range resp.Data.FetchUser.Dotfiles.Apps {
-		app, exists := allApps[appData.App]
+		appName := model.DotfileAppName(appData.App)
+		app, exists := allApps[appName]
 		if !exists {
 			logrus.Warnf("Unknown app type: %s", appData.App)
 			continue

model/dotfile_apps.go

@@ -13,6 +13,58 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+type DotfileAppName string
+
+// Available app names as enum-like constants
+const (
+	AppNvim       DotfileAppName = "nvim"
+	AppFish       DotfileAppName = "fish"
+	AppGit        DotfileAppName = "git"
+	AppZsh        DotfileAppName = "zsh"
+	AppBash       DotfileAppName = "bash"
+	AppGhostty    DotfileAppName = "ghostty"
+	AppClaude     DotfileAppName = "claude"
+	AppStarship   DotfileAppName = "starship"
+	AppNpm        DotfileAppName = "npm"
+	AppSsh        DotfileAppName = "ssh"
+	AppKitty      DotfileAppName = "kitty"
+	AppKubernetes DotfileAppName = "kubernetes"
+)
+
+// AllAvailableApps contains all available app names
+var AllAvailableApps = []DotfileAppName{
+	AppNvim,
+	AppFish,
+	AppGit,
+	AppZsh,
+	AppBash,
+	AppGhostty,
+	AppClaude,
+	AppStarship,
+	AppNpm,
+	AppSsh,
+	AppKitty,
+	AppKubernetes,
+}
+
+// GetAllAppsMap returns a map of all available app handlers
+func GetAllAppsMap() map[DotfileAppName]DotfileApp {
+	return map[DotfileAppName]DotfileApp{
+		AppNvim:       NewNvimApp(),
+		AppFish:       NewFishApp(),
+		AppGit:        NewGitApp(),
+		AppZsh:        NewZshApp(),
+		AppBash:       NewBashApp(),
+		AppGhostty:    NewGhosttyApp(),
+		AppClaude:     NewClaudeApp(),
+		AppStarship:   NewStarshipApp(),
+		AppNpm:        NewNpmApp(),
+		AppSsh:        NewSshApp(),
+		AppKitty:      NewKittyApp(),
+		AppKubernetes: NewKubernetesApp(),
+	}
+}
+
 // DotfileApp interface defines methods for handling app-specific dotfiles
 type DotfileApp interface {
 	Name() string
@@ -239,7 +291,7 @@ func (b *BaseApp) Save(ctx context.Context, files map[string]string) error {
 		// Create patches from the diffs and apply them to get merged content
 		patches := dmp.PatchMake(existingContent, diffs)
 		mergedContent, results := dmp.PatchApply(patches, existingContent)
-		
+
 		// Check if patches were applied successfully
 		for i, success := range results {
 			if !success {