Refactor: Change package.yaml schema and related Go code

This commit refactors the schema of `packages.yaml` from a list of packages with a 'type' field to a structure where packages are grouped by type directly under each group.

- Changed `data/brew/packages.yaml` to the new schema:
  `groups.<group_name>.packages.<type> = [PackageInfo]`
- Updated Go type definitions in `scripts/brew-management/pkg/types/types.go`:
    - Removed `Package` struct.
    - Introduced `PackageInfo` struct (name, tags, description, id).
    - Changed `Group.Packages` from `[]Package` to `map[string][]PackageInfo`.
- Modified Go code in `scripts/brew-management/` to align with the new types:
    - Updated YAML (un)marshalling in `pkg/yaml/`.
    - Adjusted package filtering and processing in `cmd/install/`, `cmd/prune/`, `pkg/brew/`, `pkg/convert/`, `pkg/sync/`.
    - Updated validation logic in `pkg/validate/`.
- Updated `scripts/brew-management/packages.schema.json` to reflect the new schema.
- Added `UniqueStrings` utility function.
- Ensured `validate` command works with the new schema and skips Homebrew prerequisite check.

Author: google-labs-jules[bot]

data/brew/packages.yaml

@@ -75,17 +75,18 @@ Examples:
 		}
 
 		// Get filtered packages
-		packages := yamlPkg.GetFilteredPackages(config, options)
+		filteredPackages := yamlPkg.GetFilteredPackages(config, options)
 
-		if len(packages) == 0 {
+		if len(filteredPackages) == 0 {
 			utils.PrintStatus(utils.Yellow, "No packages found matching the specified criteria.")
 			return
 		}
 
-		utils.PrintStatus(utils.Blue, fmt.Sprintf("Found %d packages to install", len(packages)))
+		utils.PrintStatus(utils.Blue, fmt.Sprintf("Found %d packages to install", len(filteredPackages)))
 
 		// Install packages
-		if err := brew.InstallPackages(packages, options); err != nil {
+		// Note: brew.InstallPackages will need to be adapted to handle []types.FilteredPackage
+		if err := brew.InstallPackages(filteredPackages, options); err != nil {
 			utils.PrintStatus(utils.Red, fmt.Sprintf("Installation failed: %v", err))
 			return
 		}
@@ -109,22 +110,22 @@ func handleListCommands(yamlFile string) error {
 			priority int
 			desc     string
 		}
-		var groups []groupInfo
+		var groupsToSort []groupInfo // Renamed to avoid conflict
 
 		for name, group := range config.Groups {
-			groups = append(groups, groupInfo{
+			groupsToSort = append(groupsToSort, groupInfo{ // Use renamed variable
 				name:     name,
 				priority: group.Priority,
 				desc:     group.Description,
 			})
 		}
 
 		// Sort by priority
-		sort.Slice(groups, func(i, j int) bool {
-			return groups[i].priority < groups[j].priority
+		sort.Slice(groupsToSort, func(i, j int) bool { // Use renamed variable
+			return groupsToSort[i].priority < groupsToSort[j].priority // Use renamed variable
 		})
 
-		for _, group := range groups {
+		for _, group := range groupsToSort { // Use renamed variable
 			fmt.Printf("  %s: %s (priority: %d)\n", group.name, group.desc, group.priority)
 		}
 	}
@@ -134,9 +135,11 @@ func handleListCommands(yamlFile string) error {
 		tagSet := make(map[string]bool)
 
 		for _, group := range config.Groups {
-			for _, pkg := range group.Packages {
-				for _, tag := range pkg.Tags {
-					tagSet[tag] = true
+			for _, pkgInfos := range group.Packages { // Iterate through map values (slices of PackageInfo)
+				for _, pkgInfo := range pkgInfos { // Iterate through PackageInfo slices
+					for _, tag := range pkgInfo.Tags { // Access Tags from PackageInfo
+						tagSet[tag] = true
+					}
 				}
 			}
 		}

scripts/brew-management/cmd/install.go

@@ -133,20 +133,24 @@ func getAllPackagesFromConfig(config *types.PackageGrouped) map[string]map[strin
 		"tap":  make(map[string]bool),
 		"brew": make(map[string]bool),
 		"cask": make(map[string]bool),
-		"mas":  make(map[string]bool),
+		"mas":  make(map[string]bool), // MAS uses ID as string key
 	}
 
 	for _, group := range config.Groups {
-		for _, pkg := range group.Packages {
-			switch pkg.Type {
-			case "tap":
-				result["tap"][pkg.Name] = true
-			case "brew":
-				result["brew"][pkg.Name] = true
-			case "cask":
-				result["cask"][pkg.Name] = true
-			case "mas":
-				result["mas"][fmt.Sprintf("%d", pkg.ID)] = true
+		for pkgType, pkgInfos := range group.Packages { // Iterate over package types (brew, cask, etc.)
+			for _, pkgInfo := range pkgInfos { // Iterate over packages of that type
+				switch pkgType {
+				case "tap":
+					result["tap"][pkgInfo.Name] = true
+				case "brew":
+					result["brew"][pkgInfo.Name] = true
+				case "cask":
+					result["cask"][pkgInfo.Name] = true
+				case "mas":
+					if pkgInfo.ID != 0 { // Ensure ID is present for MAS apps
+						result["mas"][fmt.Sprintf("%d", pkgInfo.ID)] = true
+					}
+				}
 			}
 		}
 	}

scripts/brew-management/cmd/prune.go

@@ -35,8 +35,9 @@ Examples:
   brew-manager prune --dry-run
   brew-manager validate`,
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
-		// Check prerequisites for most commands
-		if cmd.Name() != "help" && cmd.Name() != "completion" {
+		// Check prerequisites for most commands, skip for validate, help, and completion
+		commandName := cmd.Name()
+		if commandName != "validate" && commandName != "help" && commandName != "completion" {
 			if err := utils.CheckPrerequisites(); err != nil {
 				utils.PrintStatus(utils.Red, fmt.Sprintf("Error: %v", err))
 				os.Exit(1)

scripts/brew-management/cmd/root.go

@@ -18,12 +18,32 @@
           "description": "Installation priority (lower numbers install first)"
         },
         "packages": {
-          "items": {
-            "$ref": "#/$defs/Package"
-          },
-          "type": "array",
+          "type": "object",
           "title": "Packages",
-          "description": "Packages in this group"
+          "description": "Packages in this group, categorized by type",
+          "properties": {
+            "tap": {
+              "type": "array",
+              "items": { "$ref": "#/$defs/PackageInfo" },
+              "description": "Tap packages"
+            },
+            "brew": {
+              "type": "array",
+              "items": { "$ref": "#/$defs/PackageInfo" },
+              "description": "Brew formula packages"
+            },
+            "cask": {
+              "type": "array",
+              "items": { "$ref": "#/$defs/PackageInfo" },
+              "description": "Cask packages"
+            },
+            "mas": {
+              "type": "array",
+              "items": { "$ref": "#/$defs/PackageInfo" },
+              "description": "Mac App Store packages"
+            }
+          },
+          "additionalProperties": false
         }
       },
       "additionalProperties": false,
@@ -34,30 +54,20 @@
         "packages"
       ]
     },
-    "Package": {
+    "PackageInfo": {
       "properties": {
         "name": {
           "type": "string",
           "minLength": 1,
           "title": "Package Name",
           "description": "Package name"
         },
-        "type": {
-          "type": "string",
-          "enum": [
-            "tap",
-            "brew",
-            "cask",
-            "mas"
-          ],
-          "title": "Package Type",
-          "description": "Package type"
-        },
         "tags": {
           "items": {
             "type": "string"
           },
           "type": "array",
+          "uniqueItems": true,
           "title": "Tags",
           "description": "Tags for categorization and filtering"
         },
@@ -77,8 +87,7 @@
       "additionalProperties": false,
       "type": "object",
       "required": [
-        "name",
-        "type"
+        "name"
       ]
     },
     "PackageGrouped": {
@@ -119,6 +128,7 @@
             "type": "string"
           },
           "type": "array",
+          "uniqueItems": true,
           "title": "Groups",
           "description": "Groups to include in this profile"
         },
@@ -127,6 +137,7 @@
             "type": "string"
           },
           "type": "array",
+          "uniqueItems": true,
           "title": "Tags",
           "description": "Tags to include in this profile"
         },
@@ -135,6 +146,7 @@
             "type": "string"
           },
           "type": "array",
+          "uniqueItems": true,
           "title": "Exclude Tags",
           "description": "Tags to exclude from this profile"
         }

scripts/brew-management/packages.schema.json

@@ -10,23 +10,23 @@ import (
 )
 
 // InstallPackages installs packages based on configuration and options
-func InstallPackages(packages []types.Package, options *types.InstallOptions) error {
+func InstallPackages(filteredPackages []types.FilteredPackage, options *types.InstallOptions) error {
 	if err := utils.CheckPrerequisites(); err != nil {
 		return err
 	}
 
 	// Group packages by type
-	packagesByType := make(map[string][]types.Package)
-	for _, pkg := range packages {
-		packagesByType[pkg.Type] = append(packagesByType[pkg.Type], pkg)
+	packagesByType := make(map[string][]types.PackageInfo)
+	for _, filteredPkg := range filteredPackages {
+		packagesByType[filteredPkg.Type] = append(packagesByType[filteredPkg.Type], filteredPkg.PackageInfo)
 	}
 
 	// Install in order: taps, brews, casks, mas
 	order := []string{"tap", "brew", "cask", "mas"}
 
 	for _, pkgType := range order {
-		packages := packagesByType[pkgType]
-		if len(packages) == 0 {
+		pkgInfos := packagesByType[pkgType]
+		if len(pkgInfos) == 0 {
 			continue
 		}
 
@@ -35,7 +35,7 @@ func InstallPackages(packages []types.Package, options *types.InstallOptions) er
 			continue
 		}
 
-		if err := installPackagesByType(pkgType, packages, options); err != nil {
+		if err := installPackagesByType(pkgType, pkgInfos, options); err != nil {
 			return fmt.Errorf("failed to install %s packages: %w", pkgType, err)
 		}
 	}
@@ -59,41 +59,46 @@ func shouldSkipType(pkgType string, options *types.InstallOptions) bool {
 }
 
 // installPackagesByType installs packages of a specific type
-func installPackagesByType(pkgType string, packages []types.Package, options *types.InstallOptions) error {
+func installPackagesByType(pkgType string, pkgInfos []types.PackageInfo, options *types.InstallOptions) error {
 	utils.PrintStatus(utils.Blue, fmt.Sprintf("Installing %s packages...", pkgType))
 
-	for _, pkg := range packages {
+	for _, pkgInfo := range pkgInfos {
 		if options.Verbose {
-			utils.PrintStatus(utils.Cyan, fmt.Sprintf("Processing %s: %s", pkgType, pkg.Name))
+			utils.PrintStatus(utils.Cyan, fmt.Sprintf("Processing %s: %s", pkgType, pkgInfo.Name))
 		}
 
 		if options.DryRun {
-			utils.PrintStatus(utils.Yellow, fmt.Sprintf("[DRY RUN] Would install %s: %s", pkgType, pkg.Name))
+			utils.PrintStatus(utils.Yellow, fmt.Sprintf("[DRY RUN] Would install %s: %s", pkgType, pkgInfo.Name))
 			continue
 		}
 
-		if err := installSinglePackage(pkgType, pkg, options.Verbose); err != nil {
-			utils.PrintStatus(utils.Red, fmt.Sprintf("Failed to install %s: %s - %v", pkgType, pkg.Name, err))
+		if err := installSinglePackage(pkgType, pkgInfo, options.Verbose); err != nil {
+			utils.PrintStatus(utils.Red, fmt.Sprintf("Failed to install %s: %s - %v", pkgType, pkgInfo.Name, err))
+			// Decide if we should continue or stop on error. For now, continue.
 			continue
 		}
 
-		utils.PrintStatus(utils.Green, fmt.Sprintf("Installed %s: %s", pkgType, pkg.Name))
+		utils.PrintStatus(utils.Green, fmt.Sprintf("Installed %s: %s", pkgType, pkgInfo.Name))
 	}
 
 	return nil
 }
 
 // installSinglePackage installs a single package
-func installSinglePackage(pkgType string, pkg types.Package, verbose bool) error {
+func installSinglePackage(pkgType string, pkgInfo types.PackageInfo, verbose bool) error {
 	switch pkgType {
 	case "tap":
-		return installTap(pkg.Name, verbose)
+		return installTap(pkgInfo.Name, verbose)
 	case "brew":
-		return installBrew(pkg.Name, verbose)
+		return installBrew(pkgInfo.Name, verbose)
 	case "cask":
-		return installCask(pkg.Name, verbose)
+		return installCask(pkgInfo.Name, verbose)
 	case "mas":
-		return installMas(pkg.Name, pkg.ID, verbose)
+		// 'mas' type requires ID. Ensure it's present.
+		if pkgInfo.ID == 0 {
+			return fmt.Errorf("missing ID for mas package: %s", pkgInfo.Name)
+		}
+		return installMas(pkgInfo.Name, pkgInfo.ID, verbose)
 	default:
 		return fmt.Errorf("unknown package type: %s", pkgType)
 	}