feat: add Brewfile mode for curated package collections (#37)

* feat: add Brewfile mode for curated package collections

This commit introduces Brewfile mode, allowing users to launch bbrew with
a curated list of packages using the -f flag. When a Brewfile is provided,
the application displays only those packages, enabling themed collections
like IDE choosers or developer tool sets.

The implementation includes a Brewfile parser for brew and cask entries,
automatic filtering of the package catalog, and a refactored API with the
IsBrewfileMode() method for cleaner code. Critical bugs were fixed including
a synchronization issue between the displayed table and the filtered packages
array that caused incorrect package selection.

This feature is designed for Project Bluefin integration, providing curated
package experiences where users can browse predefined collections. Includes
example Brewfiles and comprehensive documentation.

* feat: add Install All functionality for Brewfile mode

Add ctrl+a keybinding to install all packages from a Brewfile at once,
available exclusively in Brewfile mode.

* feat: add Remove All for Brewfile mode

Add ctrl+r keybinding to batch remove all installed packages from
Brewfile with real-time progress counter. Validates packages are
installed before proceeding and skips non-installed packages.
Available only in Brewfile mode

Author: Valkyrie00

README.md

@@ -43,6 +43,7 @@ Bold Brew is the **official Terminal UI** for managing Homebrew in [**Project Bl
 
 - 🚀 **Modern TUI Interface** - Clean and responsive terminal user interface
 - 📦 **Complete Package Management** - Manage both Homebrew formulae and casks
+- 📋 **Brewfile Mode** - Curated package collections from Brewfiles (perfect for themed installers)
 - 🔍 **Advanced Search** - Fast fuzzy search across all packages
 - 🎯 **Smart Filters** - Filter by installed, outdated, leaves, or casks
 - 📊 **Analytics Integration** - See popular packages based on 90-day download stats
@@ -64,11 +65,27 @@ Download the latest version from the [releases page](https://github.com/Valkyrie
 
 ## 📖 Quick Start
 
-Launch the application:
+### Standard Mode
+Launch the application to browse all Homebrew packages:
 ```sh
 bbrew
 ```
 
+### Brewfile Mode (New!)
+Launch with a curated Brewfile to show only specific packages:
+```sh
+bbrew -f /path/to/Brewfile
+```
+
+In Brewfile mode, you can:
+- View only packages from the Brewfile
+- Pick and choose what to install individually
+- Use all standard features (search, filters, etc.)
+
+Perfect for creating themed collections like IDE choosers, dev tools, AI tools, K8s tools, etc.
+
+See the `examples/` directory for ready-to-use Brewfiles.
+
 ### Keyboard Shortcuts
 
 #### Navigation & Search

cmd/bbrew/main.go

@@ -2,18 +2,43 @@ package main
 
 import (
 	"bbrew/internal/services"
+	"flag"
+	"fmt"
 	"log"
+	"os"
 )
 
 func main() {
+	// Parse command line flags
+	brewfilePath := flag.String("f", "", "Path to Brewfile (show only packages from this Brewfile)")
+	flag.Parse()
+
+	// Validate Brewfile path if provided
+	if *brewfilePath != "" {
+		if _, err := os.Stat(*brewfilePath); os.IsNotExist(err) {
+			fmt.Fprintf(os.Stderr, "Error: Brewfile not found: %s\n", *brewfilePath)
+			os.Exit(1)
+		} else if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: Cannot access Brewfile: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	// Initialize app service
 	appService := services.NewAppService()
+	// Configure Brewfile mode if path was provided
+	if *brewfilePath != "" {
+		appService.SetBrewfilePath(*brewfilePath)
+	}
+
+	// Boot the application (load Homebrew data)
 	if err := appService.Boot(); err != nil {
-		log.Fatalf("Error initializing data: %v", err)
+		log.Fatalf("Failed to initialize: %v", err)
 	}
 
+	// Build and run the TUI
 	appService.BuildApp()
-
 	if err := appService.GetApp().Run(); err != nil {
-		log.Fatalf("Error running app: %v", err)
+		log.Fatalf("Application error: %v", err)
 	}
 }

examples/test.brewfile

@@ -0,0 +1,23 @@
+# Test Brewfile for bbrew
+# A simple example to test Brewfile mode functionality
+# Usage: bbrew -f test.brewfile
+
+# Command-line utilities (lightweight and common)
+brew "wget"
+brew "curl"
+brew "tree"
+brew "htop"
+brew "jq"
+
+# Development tools
+brew "git"
+brew "node"
+
+# Popular editors and IDEs
+cask "visual-studio-code"
+cask "sublime-text"
+
+# Alternative browsers (for testing)
+cask "firefox"
+cask "brave-browser"
+

internal/models/brewfile.go

@@ -0,0 +1,7 @@
+package models
+
+// BrewfileEntry represents a single entry from a Brewfile
+type BrewfileEntry struct {
+	Name   string
+	IsCask bool
+}

internal/services/app.go

@@ -24,6 +24,9 @@ type AppServiceInterface interface {
 	GetLayout() ui.LayoutInterface
 	Boot() (err error)
 	BuildApp()
+	SetBrewfilePath(path string)
+	IsBrewfileMode() bool
+	GetBrewfilePackages() *[]models.Package
 }
 
 // AppService manages the application state, Homebrew integration, and UI components.
@@ -40,6 +43,10 @@ type AppService struct {
 	showOnlyCasks     bool
 	brewVersion       string
 
+	// Brewfile support
+	brewfilePath     string
+	brewfilePackages *[]models.Package
+
 	brewService       BrewServiceInterface
 	selfUpdateService SelfUpdateServiceInterface
 	ioService         IOServiceInterface
@@ -63,6 +70,9 @@ var NewAppService = func() AppServiceInterface {
 		showOnlyLeaves:    false,
 		showOnlyCasks:     false,
 		brewVersion:       "-",
+
+		brewfilePath:     "",
+		brewfilePackages: new([]models.Package),
 	}
 
 	// Initialize services
@@ -73,8 +83,11 @@ var NewAppService = func() AppServiceInterface {
 	return s
 }
 
-func (s *AppService) GetApp() *tview.Application    { return s.app }
-func (s *AppService) GetLayout() ui.LayoutInterface { return s.layout }
+func (s *AppService) GetApp() *tview.Application             { return s.app }
+func (s *AppService) GetLayout() ui.LayoutInterface          { return s.layout }
+func (s *AppService) SetBrewfilePath(path string)            { s.brewfilePath = path }
+func (s *AppService) IsBrewfileMode() bool                   { return s.brewfilePath != "" }
+func (s *AppService) GetBrewfilePackages() *[]models.Package { return s.brewfilePackages }
 
 // Boot initializes the application by setting up Homebrew and loading formulae data.
 func (s *AppService) Boot() (err error) {
@@ -91,6 +104,42 @@ func (s *AppService) Boot() (err error) {
 	// Initialize packages and filteredPackages
 	s.packages = s.brewService.GetPackages()
 	*s.filteredPackages = *s.packages
+
+	// If Brewfile is specified, parse it and filter packages
+	if s.IsBrewfileMode() {
+		if err = s.loadBrewfilePackages(); err != nil {
+			return fmt.Errorf("failed to load Brewfile: %v", err)
+		}
+	}
+
+	return nil
+}
+
+// loadBrewfilePackages parses the Brewfile and creates a filtered package list
+func (s *AppService) loadBrewfilePackages() error {
+	entries, err := s.brewService.ParseBrewfile(s.brewfilePath)
+	if err != nil {
+		return err
+	}
+
+	// Create a map for quick lookup
+	packageMap := make(map[string]models.PackageType)
+	for _, entry := range entries {
+		if entry.IsCask {
+			packageMap[entry.Name] = models.PackageTypeCask
+		} else {
+			packageMap[entry.Name] = models.PackageTypeFormula
+		}
+	}
+
+	// Filter packages to only include those in the Brewfile
+	*s.brewfilePackages = []models.Package{}
+	for _, pkg := range *s.packages {
+		if pkgType, exists := packageMap[pkg.Name]; exists && pkgType == pkg.Type {
+			*s.brewfilePackages = append(*s.brewfilePackages, pkg)
+		}
+	}
+
 	return nil
 }
 
@@ -112,41 +161,51 @@ func (s *AppService) search(searchText string, scrollToTop bool) {
 	uniquePackages := make(map[string]bool)
 
 	// Determine the source list based on the current filter state
+	// If Brewfile mode is active, use brewfilePackages as the base source
 	sourceList := s.packages
+	if s.IsBrewfileMode() {
+		sourceList = s.brewfilePackages
+	}
+
+	// Apply filters on the base source list (either all packages or Brewfile packages)
 	if s.showOnlyInstalled && !s.showOnlyOutdated {
-		sourceList = &[]models.Package{}
-		for _, info := range *s.packages {
+		filteredSource := &[]models.Package{}
+		for _, info := range *sourceList {
 			if info.LocallyInstalled {
-				*sourceList = append(*sourceList, info)
+				*filteredSource = append(*filteredSource, info)
 			}
 		}
+		sourceList = filteredSource
 	}
 
 	if s.showOnlyOutdated {
-		sourceList = &[]models.Package{}
-		for _, info := range *s.packages {
+		filteredSource := &[]models.Package{}
+		for _, info := range *sourceList {
 			if info.LocallyInstalled && info.Outdated {
-				*sourceList = append(*sourceList, info)
+				*filteredSource = append(*filteredSource, info)
 			}
 		}
+		sourceList = filteredSource
 	}
 
 	if s.showOnlyLeaves {
-		sourceList = &[]models.Package{}
-		for _, info := range *s.packages {
+		filteredSource := &[]models.Package{}
+		for _, info := range *sourceList {
 			if info.LocallyInstalled && info.InstalledOnRequest {
-				*sourceList = append(*sourceList, info)
+				*filteredSource = append(*filteredSource, info)
 			}
 		}
+		sourceList = filteredSource
 	}
 
 	if s.showOnlyCasks {
-		sourceList = &[]models.Package{}
-		for _, info := range *s.packages {
+		filteredSource := &[]models.Package{}
+		for _, info := range *sourceList {
 			if info.Type == models.PackageTypeCask {
-				*sourceList = append(*sourceList, info)
+				*filteredSource = append(*filteredSource, info)
 			}
 		}
+		sourceList = filteredSource
 	}
 
 	if searchText == "" {
@@ -185,7 +244,14 @@ func (s *AppService) search(searchText string, scrollToTop bool) {
 func (s *AppService) forceRefreshResults() {
 	_ = s.brewService.SetupData(true)
 	s.packages = s.brewService.GetPackages()
-	*s.filteredPackages = *s.packages
+
+	// If in Brewfile mode, reload the filtered packages
+	if s.IsBrewfileMode() {
+		_ = s.loadBrewfilePackages()
+		*s.filteredPackages = *s.brewfilePackages
+	} else {
+		*s.filteredPackages = *s.packages
+	}
 
 	s.app.QueueUpdateDraw(func() {
 		s.search(s.layout.GetSearch().Field().GetText(), false)
@@ -251,7 +317,15 @@ func (s *AppService) setResults(data *[]models.Package, scrollToTop bool) {
 func (s *AppService) BuildApp() {
 	// Build the layout
 	s.layout.Setup()
-	s.layout.GetHeader().Update(AppName, AppVersion, s.brewVersion)
+
+	// Update header and enable Brewfile mode features if needed
+	headerName := AppName
+	if s.IsBrewfileMode() {
+		headerName = fmt.Sprintf("%s [Brewfile Mode]", AppName)
+		s.layout.GetSearch().Field().SetLabel("Search (Brewfile): ")
+		s.ioService.EnableBrewfileMode() // Add Install All action
+	}
+	s.layout.GetHeader().Update(headerName, AppVersion, s.brewVersion)
 
 	// Evaluate if there is a new version available
 	// This is done in a goroutine to avoid blocking the UI during startup
@@ -264,7 +338,11 @@ func (s *AppService) BuildApp() {
 		if latestVersion, err := s.selfUpdateService.CheckForUpdates(ctx); err == nil && latestVersion != AppVersion {
 			s.app.QueueUpdateDraw(func() {
 				AppVersion = fmt.Sprintf("%s ([orange]New Version Available: %s[-])", AppVersion, latestVersion)
-				s.layout.GetHeader().Update(AppName, AppVersion, s.brewVersion)
+				headerName := AppName
+				if s.IsBrewfileMode() {
+					headerName = fmt.Sprintf("%s [Brewfile Mode]", AppName)
+				}
+				s.layout.GetHeader().Update(headerName, AppVersion, s.brewVersion)
 			})
 		}
 	}()
@@ -295,6 +373,13 @@ func (s *AppService) BuildApp() {
 	s.app.SetRoot(s.layout.Root(), true)
 	s.app.SetFocus(s.layout.GetTable().View())
 
-	go s.updateHomeBrew()          // Update Async the Homebrew formulae
-	s.setResults(s.packages, true) // Set the results
+	go s.updateHomeBrew() // Update Async the Homebrew formulae
+
+	// Set initial results based on mode
+	if s.IsBrewfileMode() {
+		*s.filteredPackages = *s.brewfilePackages // Sync filteredPackages
+		s.setResults(s.brewfilePackages, true)    // Show only Brewfile packages
+	} else {
+		s.setResults(s.packages, true) // Show all packages
+	}
 }