refactor(installer): migrate RunFromSnapshot to Plan/Apply; remove unused step* functions

Add PlanFromSnapshot() to build an InstallPlan from snapshot state without
interactive prompts, respecting opts flags (Shell/Dotfiles/Macos skip).
Add SkipGit field to InstallPlan so Apply() skips git when snapshot has none.
Rewrite RunFromSnapshot to call PlanFromSnapshot + Apply + cfg.ApplyState.
Delete stepInstallPackages, stepInstallNpm, stepInstallNpmWithRetry,
stepRestoreGit, and stepRestoreMacOS which were only called by RunFromSnapshot.
Also fix pre-existing compile error in ui/macos_selector.go (pointer receiver)
and unused import in search_test.go.

Author: fullstackjam

internal/installer/installer.go

@@ -88,7 +88,7 @@ func runInstall(opts *config.InstallOptions, st *config.InstallState) error {
 // Apply executes a resolved InstallPlan, reporting progress via r.
 // All user interaction has already happened in Plan(); this function only performs actions.
 func Apply(plan InstallPlan, r Reporter) error {
-	if !plan.PackagesOnly {
+	if !plan.PackagesOnly && !plan.SkipGit {
 		if err := applyGitConfig(plan, r); err != nil {
 			return err
 		}
@@ -228,60 +228,10 @@ func RunFromSnapshot(cfg *config.Config) error {
 		fmt.Println()
 	}
 
-	if len(st.SnapshotTaps) > 0 {
-		ui.Info(fmt.Sprintf("Adding %d taps...", len(st.SnapshotTaps)))
-		fmt.Println()
-		if err := brew.InstallTaps(st.SnapshotTaps, opts.DryRun); err != nil {
-			ui.Warn(fmt.Sprintf("Some taps failed: %v", err))
-		}
-		fmt.Println()
-	}
-
-	if err := stepInstallPackages(opts, st); err != nil {
-		cfg.ApplyState(st)
-		return err
-	}
-
-	if err := stepInstallNpmWithRetry(opts, st); err != nil {
-		ui.Error(fmt.Sprintf("npm package installation failed: %v", err))
-	}
-
-	var softErrs []error
-
-	if st.SnapshotGit != nil {
-		if err := stepRestoreGit(opts, st); err != nil {
-			ui.Error(fmt.Sprintf("Git restore failed: %v", err))
-			softErrs = append(softErrs, fmt.Errorf("git restore: %w", err))
-		}
-	}
-
-	if err := stepShell(opts, st); err != nil {
-		ui.Error(fmt.Sprintf("Shell setup failed: %v", err))
-		softErrs = append(softErrs, fmt.Errorf("shell: %w", err))
-	}
-
-	if err := stepRestoreMacOS(opts, st); err != nil {
-		ui.Error(fmt.Sprintf("macOS restore failed: %v", err))
-		softErrs = append(softErrs, fmt.Errorf("macos: %w", err))
-	}
-
-	if st.SnapshotDotfiles != "" {
-		if err := stepDotfiles(opts, st); err != nil {
-			ui.Error(fmt.Sprintf("Dotfiles restore failed: %v", err))
-			softErrs = append(softErrs, fmt.Errorf("dotfiles: %w", err))
-		}
-	}
-
-	showCompletion(opts, st)
-
+	plan := PlanFromSnapshot(opts, st)
+	err := Apply(plan, ConsoleReporter{})
 	cfg.ApplyState(st)
-
-	if len(softErrs) > 0 {
-		fmt.Println()
-		ui.Warn(fmt.Sprintf("%d restore step(s) had errors — check the output above for details.", len(softErrs)))
-		return errors.Join(softErrs...)
-	}
-	return nil
+	return err
 }
 
 func runUpdate(opts *config.InstallOptions, st *config.InstallState) error {
@@ -293,7 +243,7 @@ func runUpdate(opts *config.InstallOptions, st *config.InstallState) error {
 	}
 
 	if !opts.DryRun {
-		brew.Cleanup()
+		brew.Cleanup() //nolint:errcheck // best-effort cleanup; failure is non-critical
 	}
 
 	fmt.Println()

internal/installer/plan.go

@@ -23,6 +23,7 @@ type InstallPlan struct {
 	// Git
 	GitName  string
 	GitEmail string
+	SkipGit  bool // when true, Apply skips git configuration entirely
 
 	// Packages (fully resolved and categorized)
 	Formulae     []string
@@ -246,7 +247,7 @@ func planDotfilesDecision(opts *config.InstallOptions) (string, error) {
 		return url, nil
 	}
 
-	if !opts.Silent && !(opts.DryRun && !system.HasTTY()) {
+	if !opts.Silent && (!opts.DryRun || system.HasTTY()) {
 		setup, err := ui.Confirm("Do you have your own dotfiles repository?", false)
 		if err != nil {
 			return "", err
@@ -285,3 +286,62 @@ func planMacOSDecision(opts *config.InstallOptions) ([]macos.Preference, error)
 	}
 	return selected, nil
 }
+
+// PlanFromSnapshot builds an InstallPlan from snapshot state without any interactive
+// prompts. All decisions are derived from st.Snapshot* fields and opts.
+func PlanFromSnapshot(opts *config.InstallOptions, st *config.InstallState) InstallPlan {
+	plan := InstallPlan{
+		Version:          opts.Version,
+		DryRun:           opts.DryRun,
+		Silent:           opts.Silent,
+		PackagesOnly:     opts.PackagesOnly,
+		AllowPostInstall: opts.AllowPostInstall,
+		Taps:             st.SnapshotTaps,
+		SelectedPkgs:     st.SelectedPkgs,
+	}
+
+	// Categorize selected packages into formulae, casks, and npm.
+	cats := categorizeSelectedPackages(opts, st)
+	plan.Formulae = cats.cli
+	plan.Casks = cats.cask
+	plan.Npm = cats.npm
+
+	// Git: restore from snapshot when present; skip entirely when snapshot has no git config.
+	if st.SnapshotGit != nil {
+		plan.GitName = st.SnapshotGit.UserName
+		plan.GitEmail = st.SnapshotGit.UserEmail
+	} else {
+		plan.SkipGit = true
+	}
+
+	// Dotfiles: non-empty snapshot URL means apply, unless explicitly skipped via flag.
+	if opts.Dotfiles != "skip" {
+		plan.DotfilesURL = st.SnapshotDotfiles
+	}
+
+	// Shell: attempt Oh-My-Zsh for snapshot restores unless explicitly skipped.
+	if opts.Shell != "skip" {
+		plan.InstallOhMyZsh = true
+	}
+
+	// macOS: convert snapshot preferences to macos.Preference values, unless skipped via flag.
+	if opts.Macos != "skip" && len(st.SnapshotMacOS) > 0 {
+		prefs := make([]macos.Preference, 0, len(st.SnapshotMacOS))
+		for _, p := range st.SnapshotMacOS {
+			prefType := p.Type
+			if prefType == "" {
+				prefType = macos.InferPreferenceType(p.Value)
+			}
+			prefs = append(prefs, macos.Preference{
+				Domain: p.Domain,
+				Key:    p.Key,
+				Type:   prefType,
+				Value:  p.Value,
+				Desc:   p.Desc,
+			})
+		}
+		plan.MacOSPrefs = prefs
+	}
+
+	return plan
+}

internal/installer/step_git.go

@@ -91,58 +91,3 @@ func stepGitConfig(opts *config.InstallOptions, st *config.InstallState) error {
 	return nil
 }
 
-func stepRestoreGit(opts *config.InstallOptions, st *config.InstallState) error {
-	ui.Header("Restore: Git Configuration")
-	fmt.Println()
-
-	git := st.SnapshotGit
-	if git.UserName == "" && git.UserEmail == "" {
-		ui.Muted("No git config in snapshot, skipping")
-		fmt.Println()
-		return nil
-	}
-
-	existingName, existingEmail := system.GetExistingGitConfig()
-
-	if existingName != "" && existingEmail != "" {
-		ui.Success(fmt.Sprintf("✓ Already configured: %s <%s>", existingName, existingEmail))
-		fmt.Println()
-		return nil
-	}
-
-	if opts.DryRun {
-		if existingName == "" && git.UserName != "" {
-			fmt.Printf("[DRY-RUN] Would set git user.name = %s\n", git.UserName)
-		}
-		if existingEmail == "" && git.UserEmail != "" {
-			fmt.Printf("[DRY-RUN] Would set git user.email = %s\n", git.UserEmail)
-		}
-		fmt.Println()
-		return nil
-	}
-
-	nameToSet := existingName
-	emailToSet := existingEmail
-	if existingName == "" && git.UserName != "" {
-		nameToSet = git.UserName
-	}
-	if existingEmail == "" && git.UserEmail != "" {
-		emailToSet = git.UserEmail
-	}
-
-	if nameToSet == "" || emailToSet == "" {
-		ui.Warn("Incomplete git config in snapshot, skipping (need both name and email)")
-		fmt.Println()
-		return nil
-	}
-
-	if nameToSet != existingName || emailToSet != existingEmail {
-		if err := system.ConfigureGit(nameToSet, emailToSet); err != nil {
-			return fmt.Errorf("restore git config: %w", err)
-		}
-	}
-
-	ui.Success(fmt.Sprintf("Git restored: %s <%s>", nameToSet, emailToSet))
-	fmt.Println()
-	return nil
-}