feat(cleaner): support tap diffing in DiffFromLists

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: fullstackjam

internal/cleaner/cleaner.go

@@ -14,41 +14,45 @@ type CleanResult struct {
 	ExtraFormulae []string
 	ExtraCasks    []string
 	ExtraNpm      []string
+	ExtraTaps     []string
 
 	RemovedFormulae []string
 	RemovedCasks    []string
 	RemovedNpm      []string
+	RemovedTaps     []string
 
 	FailedFormulae []string
 	FailedCasks    []string
 	FailedNpm      []string
+	FailedTaps     []string
 }
 
 func (r *CleanResult) TotalExtra() int {
-	return len(r.ExtraFormulae) + len(r.ExtraCasks) + len(r.ExtraNpm)
+	return len(r.ExtraFormulae) + len(r.ExtraCasks) + len(r.ExtraNpm) + len(r.ExtraTaps)
 }
 
 func (r *CleanResult) TotalRemoved() int {
-	return len(r.RemovedFormulae) + len(r.RemovedCasks) + len(r.RemovedNpm)
+	return len(r.RemovedFormulae) + len(r.RemovedCasks) + len(r.RemovedNpm) + len(r.RemovedTaps)
 }
 
 func (r *CleanResult) TotalFailed() int {
-	return len(r.FailedFormulae) + len(r.FailedCasks) + len(r.FailedNpm)
+	return len(r.FailedFormulae) + len(r.FailedCasks) + len(r.FailedNpm) + len(r.FailedTaps)
 }
 
 func DiffFromSnapshot(snap *snapshot.Snapshot) (*CleanResult, error) {
-	desiredFormulae := toSet(snap.Packages.Formulae)
-	desiredCasks := toSet(snap.Packages.Casks)
-	desiredNpm := toSet(snap.Packages.Npm)
-
-	return diff(desiredFormulae, desiredCasks, desiredNpm)
+	return diff(
+		toSet(snap.Packages.Formulae),
+		toSet(snap.Packages.Casks),
+		toSet(snap.Packages.Npm),
+		toSet(snap.Packages.Taps),
+	)
 }
 
-func DiffFromLists(formulae, casks, npmPkgs []string) (*CleanResult, error) {
-	return diff(toSet(formulae), toSet(casks), toSet(npmPkgs))
+func DiffFromLists(formulae, casks, npmPkgs, taps []string) (*CleanResult, error) {
+	return diff(toSet(formulae), toSet(casks), toSet(npmPkgs), toSet(taps))
 }
 
-func diff(desiredFormulae, desiredCasks, desiredNpm map[string]bool) (*CleanResult, error) {
+func diff(desiredFormulae, desiredCasks, desiredNpm, desiredTaps map[string]bool) (*CleanResult, error) {
 	result := &CleanResult{}
 
 	installedFormulae, installedCasks, err := brew.GetInstalledPackages()
@@ -81,6 +85,19 @@ func diff(desiredFormulae, desiredCasks, desiredNpm map[string]bool) (*CleanResu
 		}
 	}
 
+	if len(desiredTaps) > 0 {
+		installedTaps, err := brew.GetInstalledTaps()
+		if err != nil {
+			ui.Warn(fmt.Sprintf("Failed to check taps: %v", err))
+		} else {
+			for _, tap := range installedTaps {
+				if !desiredTaps[tap] {
+					result.ExtraTaps = append(result.ExtraTaps, tap)
+				}
+			}
+		}
+	}
+
 	return result, nil
 }
 
@@ -117,6 +134,13 @@ func Execute(result *CleanResult, dryRun bool) error {
 			removed:      &result.RemovedNpm,
 			failed:       &result.FailedNpm,
 		},
+		{
+			label:        "Removing extra taps",
+			pkgs:         result.ExtraTaps,
+			uninstallOne: func(tap string, dry bool) error { return brew.Untap([]string{tap}, dry) },
+			removed:      &result.RemovedTaps,
+			failed:       &result.FailedTaps,
+		},
 	}
 
 	var errs []error

internal/cleaner/cleaner_test.go

@@ -2,12 +2,24 @@ package cleaner
 
 import (
 	"errors"
+	"os"
+	"path/filepath"
 	"testing"
 
+	"github.com/openbootdotdev/openboot/internal/snapshot"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+func setupFakeBrew(t *testing.T, script string) {
+	t.Helper()
+	tmpDir := t.TempDir()
+	brewPath := filepath.Join(tmpDir, "brew")
+	require.NoError(t, os.WriteFile(brewPath, []byte(script), 0755))
+	originalPath := os.Getenv("PATH")
+	t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+originalPath)
+}
+
 func TestToSet(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -198,3 +210,152 @@ func TestExecute_DryRun_PassedThrough(t *testing.T) {
 	assert.True(t, sawDryRun)
 	assert.Equal(t, []string{"typescript", "eslint"}, result.RemovedNpm)
 }
+
+func TestExecute_EmptyResult(t *testing.T) {
+	result := &CleanResult{}
+	err := Execute(result, false)
+	assert.NoError(t, err)
+	assert.Equal(t, 0, result.TotalRemoved())
+	assert.Equal(t, 0, result.TotalFailed())
+}
+
+func TestExecute_DryRun_Formulae(t *testing.T) {
+	result := &CleanResult{
+		ExtraFormulae: []string{"wget", "curl"},
+	}
+	err := Execute(result, true)
+	assert.NoError(t, err)
+}
+
+func TestExecute_WithFakeBrew_Success(t *testing.T) {
+	setupFakeBrew(t, "#!/bin/sh\nexit 0\n")
+	result := &CleanResult{
+		ExtraFormulae: []string{"wget"},
+		ExtraCasks:    []string{"firefox"},
+	}
+	err := Execute(result, false)
+	assert.NoError(t, err)
+	assert.Contains(t, result.RemovedFormulae, "wget")
+	assert.Contains(t, result.RemovedCasks, "firefox")
+	assert.Empty(t, result.FailedFormulae)
+	assert.Empty(t, result.FailedCasks)
+}
+
+func TestExecute_WithFakeBrew_Failure(t *testing.T) {
+	setupFakeBrew(t, "#!/bin/sh\necho 'Error: No such keg'\nexit 1\n")
+	result := &CleanResult{
+		ExtraFormulae: []string{"bad-pkg"},
+	}
+	err := Execute(result, false)
+	assert.Error(t, err)
+	assert.Contains(t, result.FailedFormulae, "bad-pkg")
+	assert.Empty(t, result.RemovedFormulae)
+}
+
+func TestDiffFromLists_ExtraPackages(t *testing.T) {
+	setupFakeBrew(t, "#!/bin/sh\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--formula\" ]; then\n"+
+		"  echo git\n"+
+		"  echo wget\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--cask\" ]; then\n"+
+		"  echo firefox\n"+
+		"  echo slack\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"exit 0\n")
+
+	result, err := DiffFromLists([]string{"git"}, []string{"firefox"}, nil, nil)
+	require.NoError(t, err)
+	assert.Contains(t, result.ExtraFormulae, "wget")
+	assert.NotContains(t, result.ExtraFormulae, "git")
+	assert.Contains(t, result.ExtraCasks, "slack")
+	assert.NotContains(t, result.ExtraCasks, "firefox")
+}
+
+func TestDiffFromLists_NoExtras(t *testing.T) {
+	setupFakeBrew(t, "#!/bin/sh\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--formula\" ]; then\n"+
+		"  echo git\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--cask\" ]; then\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"exit 0\n")
+
+	result, err := DiffFromLists([]string{"git"}, nil, nil, nil)
+	require.NoError(t, err)
+	assert.Empty(t, result.ExtraFormulae)
+	assert.Empty(t, result.ExtraCasks)
+}
+
+func TestDiffFromLists_WithExtraTaps(t *testing.T) {
+	setupFakeBrew(t, "#!/bin/sh\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--formula\" ]; then\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--cask\" ]; then\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"if [ \"$1\" = \"tap\" ]; then\n"+
+		"  echo homebrew/cask-fonts\n"+
+		"  echo hashicorp/tap\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"exit 0\n")
+
+	result, err := DiffFromLists(nil, nil, nil, []string{"homebrew/cask-fonts"})
+	require.NoError(t, err)
+	assert.Contains(t, result.ExtraTaps, "hashicorp/tap", "tap not in desired list should be extra")
+	assert.NotContains(t, result.ExtraTaps, "homebrew/cask-fonts", "desired tap should not be extra")
+}
+
+func TestDiffFromLists_TapsPathSkippedWhenEmpty(t *testing.T) {
+	setupFakeBrew(t, "#!/bin/sh\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--formula\" ]; then\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--cask\" ]; then\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"exit 0\n")
+
+	result, err := DiffFromLists(nil, nil, nil, nil)
+	require.NoError(t, err)
+	assert.Empty(t, result.ExtraTaps)
+}
+
+func TestCleanResult_TotalExtra_WithTaps(t *testing.T) {
+	r := &CleanResult{
+		ExtraFormulae: []string{"a"},
+		ExtraCasks:    []string{"b"},
+		ExtraNpm:      []string{"c"},
+		ExtraTaps:     []string{"d", "e"},
+	}
+	assert.Equal(t, 5, r.TotalExtra())
+}
+
+func TestDiffFromSnapshot_ExtraPackages(t *testing.T) {
+	setupFakeBrew(t, "#!/bin/sh\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--formula\" ]; then\n"+
+		"  echo git\n"+
+		"  echo ripgrep\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"if [ \"$1\" = \"list\" ] && [ \"$2\" = \"--cask\" ]; then\n"+
+		"  exit 0\n"+
+		"fi\n"+
+		"exit 0\n")
+
+	snap := &snapshot.Snapshot{
+		Packages: snapshot.PackageSnapshot{
+			Formulae: []string{"git"},
+		},
+	}
+	result, err := DiffFromSnapshot(snap)
+	require.NoError(t, err)
+	assert.Contains(t, result.ExtraFormulae, "ripgrep")
+	assert.NotContains(t, result.ExtraFormulae, "git")
+}