Minor Update 2

changes to main.go:
```
- refactor basically the entire file to use less switch statements and more slices
- implement the toolcheck functionality
- add the toolcheck command
```

changes to snap.go:
```
- fix the exec.Command call to use args properly
- fix up snap.go to handle the pkg.list properly
```

cmd/main.go

@@ -9,6 +9,7 @@ import (
 	"strings"
     "pixelridgesoftworks.com/AllPac/pkg/packagemanager"
 	"pixelridgesoftworks.com/AllPac/pkg/logger"
+    "pixelridgesoftworks.com/AllPac/pkg/toolcheck"
 	"path/filepath"
     "regexp"
 )
@@ -17,67 +18,64 @@ func main() {
     // Initialize the logger
     logFilePath := filepath.Join(os.Getenv("HOME"), ".allpac", "logs", "allpac.log")
     if err := logger.Init(logFilePath); err != nil {
-		// If logger initialization fails, you can choose to exit the program or use the default logger
         logger.Errorf("Failed to initialize logger: %v", err)
     }
-    // Define flags for different commands
+
-    updateCmd := flag.NewFlagSet("update", flag.ExitOnError)
+    // Define flag sets for different commands
-    installCmd := flag.NewFlagSet("install", flag.ExitOnError)
+    commandHandlers := map[string]func(*flag.FlagSet){
-    uninstallCmd := flag.NewFlagSet("uninstall", flag.ExitOnError)
+        "update":     handleUpdate,
-    searchCmd := flag.NewFlagSet("search", flag.ExitOnError)
+        "install":    handleInstall,
-	aurRebuildCmd := flag.NewFlagSet("rebuild", flag.ExitOnError)
+        "uninstall":  handleUninstall,
-	aurCleanCmd := flag.NewFlagSet("clean-aur", flag.ExitOnError)
+        "search":     func(cmd *flag.FlagSet) { handleSearch(cmd, os.Args[2:]) },
+        "rebuild":    handleRebuild,
+        "clean-aur":  handleCleanAur,
+        "toolcheck":  handleToolCheck,
+    }
 
     if len(os.Args) < 2 {
-        fmt.Println("Expected 'update', 'install', 'uninstall', 'search', 'rebuild', or 'clean-aur' subcommands")
+        fmt.Println("Expected 'update', 'install', 'uninstall', 'search', 'rebuild', 'clean-aur', or 'toolcheck' subcommands")
         os.Exit(1)
     }
 
-    switch os.Args[1] {
+    if handler, ok := commandHandlers[os.Args[1]]; ok {
-    case "update":
+        cmd := flag.NewFlagSet(os.Args[1], flag.ExitOnError)
-        handleUpdate(updateCmd)
+        handler(cmd)
-    case "install":
+    } else {
-        handleInstall(installCmd)
-    case "uninstall":
-        handleUninstall(uninstallCmd)
-    case "search":
-        handleSearch(searchCmd, os.Args[2:])
-	case "rebuild":
-		handleRebuild(aurRebuildCmd)
-	case "clean-aur":
-		handleCleanAur(aurCleanCmd)
-    default:
         fmt.Printf("Unknown subcommand: %s\n", os.Args[1])
         os.Exit(1)
     }
 }
 
 func handleUpdate(cmd *flag.FlagSet) {
-    everythingFlag := cmd.Bool("everything", false, "Update all packages on the system")
+    updateFlags := map[string]*bool{
-    snapFlag := cmd.Bool("snap", false, "Update all Snap packages")
+        "everything": cmd.Bool("everything", false, "Update all packages on the system"),
-    aurFlag := cmd.Bool("aur", false, "Update all AUR packages")
+        "snap":       cmd.Bool("snap", false, "Update all Snap packages"),
-    archFlag := cmd.Bool("arch", false, "Update all Arch packages")
+        "aur":        cmd.Bool("aur", false, "Update all AUR packages"),
-    flatsFlag := cmd.Bool("flats", false, "Update all Flatpak packages")
+        "arch":       cmd.Bool("arch", false, "Update all Arch packages"),
+        "flats":      cmd.Bool("flats", false, "Update all Flatpak packages"),
+    }
     cmd.Parse(os.Args[2:])
 
-    if *everythingFlag {
+    updateFuncs := map[string]func() error{
-        // Call function to update all packages
+        "everything": packagemanager.UpdateAllPackages,
-        packagemanager.UpdateAllPackages()
+        "snap":       func() error { return packagemanager.UpdateSnapPackages() },
-    } else if *snapFlag {
+        "aur":        func() error { return packagemanager.UpdateAURPackages() },
-        // Call function to update Snap packages
+        "arch":       func() error { return packagemanager.UpdatePacmanPackages() },
-        packagemanager.UpdateSnapPackages()
+        "flats":      func() error { return packagemanager.UpdateFlatpakPackages() },
-    } else if *aurFlag {
-        // Call function to update AUR packages
-        packagemanager.UpdateAURPackages()
-    } else if *archFlag {
-        // Call function to update Arch packages
-        packagemanager.UpdatePacmanPackages()
-    } else if *flatsFlag {
-        // Call function to update Flatpak packages
-        packagemanager.UpdateFlatpakPackages()
-    } else {
-        fmt.Println("No update option specified or unrecognized option")
     }
+
+    for flagName, flagValue := range updateFlags {
+        if *flagValue {
+            if updateFunc, ok := updateFuncs[flagName]; ok {
+                if err := updateFunc(); err != nil {
+                    fmt.Printf("Error occurred during '%s' update: %v\n", flagName, err)
+                }
+                return
+            }
+        }
+    }
+
+    fmt.Println("No update option specified or unrecognized option")
 }
 
 // handles the install command for packages
@@ -98,10 +96,18 @@ func handleInstall(cmd *flag.FlagSet) {
         return
     }
 
+    installFuncs := map[string]func(string) error{
+        "Pacman": packagemanager.InstallPackagePacman,
+        "Snap":   packagemanager.InstallPackageSnap,
+        "Flatpak": packagemanager.InstallPackageFlatpak,
+        "AUR": func(pkgName string) error {
+            _, err := packagemanager.CloneAndInstallFromAUR(fmt.Sprintf("https://aur.archlinux.org/%s.git", pkgName), false)
+            return err
+        },
+    }
+
     for _, result := range searchResults {
         fmt.Printf("Searching for package: %s\n", result.PackageName)
-
-        // Filter for exact matches
         exactMatches := filterExactMatches(result.PackageName, result.Results)
 
         if len(exactMatches) == 0 {
@@ -109,42 +115,35 @@ func handleInstall(cmd *flag.FlagSet) {
             continue
         }
 
-        var selectedSource string
+        selectedSource := getSelectedSource(exactMatches)
-        if len(exactMatches) == 1 {
+        if selectedSource == "" {
-            // Only one source available, use it automatically
-            selectedSource = exactMatches[0].Source
-        } else {
-            // Multiple sources available, prompt the user to choose
-            sourceIndex := promptUserForSource(exactMatches)
-            if sourceIndex < 0 || sourceIndex >= len(exactMatches) {
-                fmt.Println("Invalid selection. Skipping package.")
             continue
         }
-            selectedSource = exactMatches[sourceIndex].Source
-        }
 
         fmt.Printf("Installing %s from %s...\n", result.PackageName, selectedSource)
-
+        if installFunc, ok := installFuncs[selectedSource]; ok {
-        switch selectedSource {
+            if err := installFunc(result.PackageName); err != nil {
-        case "Pacman":
-            err = packagemanager.InstallPackagePacman(result.PackageName)
-        case "Snap":
-            err = packagemanager.InstallPackageSnap(result.PackageName)
-        case "Flatpak":
-            err = packagemanager.InstallPackageFlatpak(result.PackageName)
-        case "AUR":
-            _, err = packagemanager.CloneAndInstallFromAUR(fmt.Sprintf("https://aur.archlinux.org/%s.git", result.PackageName), false)
-        default:
-            fmt.Printf("Unknown source for package %s\n", result.PackageName)
-            continue
-        }
-
-        if err != nil {
                 fmt.Printf("Error installing package %s from %s: %v\n", result.PackageName, selectedSource, err)
             } else {
                 fmt.Printf("Package %s installed successfully from %s.\n", result.PackageName, selectedSource)
             }
+        } else {
+            fmt.Printf("Unknown source for package %s\n", result.PackageName)
         }
+    }
+}
+
+func getSelectedSource(exactMatches []packagemanager.SourceResult) string {
+    if len(exactMatches) == 1 {
+        return exactMatches[0].Source
+    }
+
+    sourceIndex := promptUserForSource(exactMatches)
+    if sourceIndex < 0 || sourceIndex >= len(exactMatches) {
+        fmt.Println("Invalid selection. Skipping package.")
+        return ""
+    }
+    return exactMatches[sourceIndex].Source
 }
 
 // filters the search results to include only those with an exact match
@@ -171,22 +170,18 @@ func isExactMatch(packageName, result string) bool {
     return matched
 }
 
-// handleUninstall handles the uninstall command for packages
+// handles the uninstall command for packages
 func handleUninstall(cmd *flag.FlagSet) {
-    // Define a flag for accepting multiple package names
     packageNames := cmd.String("packages", "", "Comma-separated list of packages to uninstall")
 
-    // Parse the command line arguments
     cmd.Parse(os.Args[2:])
 
-    // Check if the package names were provided
     if *packageNames == "" {
         fmt.Println("You must specify at least one package name.")
         cmd.Usage()
         return
     }
 
-    // Split the package names and convert to a slice
     packages := strings.Split(*packageNames, ",")
 
     // Call the function to uninstall the packages
@@ -198,81 +193,56 @@ func handleUninstall(cmd *flag.FlagSet) {
     }
 }
 
-// handleSearch handles the search command for packages across different package managers
+// handles the search command for packages across different package managers
 func handleSearch(cmd *flag.FlagSet, args []string) {
-    // Check if the package name was provided
     if len(args) < 1 {
         fmt.Println("You must specify a package name.")
         cmd.Usage()
         return
     }
 
-    // The package name is the first argument
     packageName := args[0]
 
-    // Search in Pacman
+    // Search across all sources
-    pacmanResults, err := packagemanager.SearchPacman(packageName)
+    searchResults, err := packagemanager.SearchAllSources([]string{packageName})
     if err != nil {
-        logger.Errorf("Error searching in Pacman: %v", err)
+        logger.Errorf("Error searching for package %s: %v", packageName, err)
-    } else if len(pacmanResults) == 0 {
+        return
-        fmt.Println("Pacman: No results found")
-    } else {
-        fmt.Println("Pacman Results:")
-        for _, result := range pacmanResults {
-            fmt.Println(result)
-        }
     }
 
-    // Search in Snap
+    if len(searchResults) == 0 {
-    snapResults, err := packagemanager.SearchSnap(packageName)
+        fmt.Println("No results found for package:", packageName)
-    if err != nil {
+        return
-        fmt.Printf("Error searching in Snap: %v\n", err)
-    } else {
-        fmt.Println("Snap Results:")
-        for _, result := range snapResults {
-            fmt.Println(result)
-        }
     }
 
-    // Search in Flatpak
+    // Iterate over the search results and print them
-    flatpakResults, err := packagemanager.SearchFlatpak(packageName)
+    for _, result := range searchResults {
-    if err != nil {
+        if len(result.Results) == 0 {
-        fmt.Printf("Error searching in Flatpak: %v\n", err)
+            fmt.Printf("%s: No results found\n", result.PackageName)
-    } else {
+            continue
-        fmt.Println("Flatpak Results:")
-        for _, result := range flatpakResults {
-            fmt.Println(result)
-        }
         }
 
-    // Search in AUR
+        for _, sourceResult := range result.Results {
-    aurResults, err := packagemanager.SearchAUR(packageName)
+            fmt.Printf("%s Results from %s:\n", result.PackageName, sourceResult.Source)
-    if err != nil {
+            for _, res := range sourceResult.Results {
-        fmt.Printf("Error searching in AUR: %v\n", err)
+                fmt.Println(res)
-    } else {
+            }
-        fmt.Println("AUR Results:")
-        for _, result := range aurResults {
-            fmt.Printf("%s - %s\n", result.Name, result.Version)
         }
     }
 }
 
-// handleRebuild handles the rebuild command for an AUR package
+// handles the rebuild command for an AUR package
 func handleRebuild(cmd *flag.FlagSet) {
-    // Define a flag for the package name
     packageName := cmd.String("package", "", "Name of the AUR package to rebuild")
 
-    // Parse the command line arguments
     cmd.Parse(os.Args[2:])
 
-    // Check if the package name was provided
     if *packageName == "" {
         fmt.Println("You must specify a package name.")
         cmd.Usage()
         return
     }
 
-    // Call the function to rebuild and reinstall the AUR package
     err := packagemanager.RebuildAndReinstallAURPackage(*packageName)
     if err != nil {
         fmt.Printf("Error rebuilding package %s: %v\n", *packageName, err)
@@ -281,7 +251,7 @@ func handleRebuild(cmd *flag.FlagSet) {
     }
 }
 
-// handleCleanAur handles the cleaning of AUR cache
+// handles the cleaning of AUR cache
 func handleCleanAur(cmd *flag.FlagSet) {
     // Parse the command flags if needed
     cmd.Parse(os.Args[2:])
@@ -289,11 +259,11 @@ func handleCleanAur(cmd *flag.FlagSet) {
     // Call the function to clear the AUR cache
     err := packagemanager.ClearAllPacCache()
     if err != nil {
-        fmt.Printf("Error clearing AUR cache: %v\n", err)
+        fmt.Printf("Error clearing AllPac cache: %v\n", err)
         return
     }
 
-    fmt.Println("AUR cache cleared successfully.")
+    fmt.Println("AllPac cache cleared successfully.")
 }
 
 // prompts the user to select a source for installation
@@ -306,3 +276,24 @@ func promptUserForSource(sources []packagemanager.SourceResult) int {
     fmt.Scan(&choice)
     return choice
 }
+
+func handleToolCheck(cmd *flag.FlagSet) {
+    checks := []struct {
+        Name string
+        Func func() error
+    }{
+        {"Pacman", toolcheck.EnsurePacman},
+        {"Base-devel", toolcheck.EnsureBaseDevel},
+        {"Git", toolcheck.EnsureGit},
+        {"Snap", toolcheck.EnsureSnap},
+        {"Flatpak", toolcheck.EnsureFlatpak},
+    }
+
+    for _, check := range checks {
+        if err := check.Func(); err != nil {
+            fmt.Printf("%s check failed: %v\n", check.Name, err)
+        } else {
+            fmt.Printf("%s is installed and available.\n", check.Name)
+        }
+    }
+}

pkg/packagemanager/snap.go

@@ -31,8 +31,8 @@ func UpdateSnapPackages(packageNames ...string) error {
     if len(packageNames) == 0 {
         cmd = exec.Command("sudo", "snap", "refresh")
     } else {
-        args := append([]string{"refresh"}, packageNames...)
+        args := append([]string{"snap", "refresh"}, packageNames...)
-        cmd = exec.Command("sudo", "snap", args...)
+        cmd = exec.Command("sudo", args...)
     }
 
     if output, err := cmd.CombinedOutput(); err != nil {
@@ -58,11 +58,33 @@ func UpdateSnapPackages(packageNames ...string) error {
 
 // UninstallSnapPackage uninstalls a specified Snap package
 func UninstallSnapPackage(packageName string) error {
+    // Read the current package list
+    pkgList, err := ReadPackageList()
+    if err != nil {
+        logger.Errorf("An error has occurred while reading the package list: %v", err)
+        return err
+    }
+
+    // Check if the package is managed by AllPac
+    if _, exists := pkgList[packageName]; !exists {
+        logger.Infof("Package %s not found in the package list, may not be managed by AllPac", packageName)
+        return nil
+    }
+
+    // Uninstalling the Snap package
     cmd := exec.Command("sudo", "snap", "remove", packageName)
     if output, err := cmd.CombinedOutput(); err != nil {
         logger.Errorf("error uninstalling Snap package: %s, %v", string(output), err)
         return fmt.Errorf("error uninstalling Snap package: %s, %v", string(output), err)
     }
+
+    // Remove the package from the list after successful uninstallation
+    if err := RemovePackageFromList(packageName); err != nil {
+        logger.Errorf("An error has occurred while removing the package from the list: %v", err)
+        return err
+    }
+
+    logger.Infof("Package %s successfully uninstalled and removed from the package list", packageName)
     return nil
 }