feat(cli): add first implementation for install command

cargo.go

@@ -34,3 +34,12 @@ func (c *CargoManager) InstallPackage(pkg string) error {
 	cmd := execCommand("cargo", "install", pkg)
 	return cmd.Run()
 }
+
+func (c *CargoManager) RemovePackage(pkg string) error {
+	cmd := execCommand("cargo", "uninstall", pkg)
+	return cmd.Run()
+}
+
+func (c *CargoManager) SearchPackage(pkg string) []string {
+	return []string{}
+}

cmd.go

@@ -2,10 +2,7 @@ package main
 
 import (
 	"fmt"
-	"log"
 	"os"
-	"os/exec"
-	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -17,24 +14,6 @@ var rootCmd = &cobra.Command{
 	Run:   run,
 }
 
-var searchCmd = &cobra.Command{
-	Use:   "search [package_name]",
-	Short: "Search for a package across package managers (will search in os|flatpak|homebrew)",
-	Args:  cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		packageName := args[0]
-
-		managers := []string{"brew", "os", "flatpak"}
-
-		for _, manager := range managers {
-			fmt.Printf("Searching in %s:\n", manager)
-			results := searchPackage(packageName, manager)
-			displayResults(results, manager)
-			fmt.Println()
-		}
-	},
-}
-
 func init() {
 	cobra.OnInitialize(initConfig)
 	rootCmd.PersistentFlags().StringP("config", "c", "", "Path to the configuration file")
@@ -52,8 +31,14 @@ func init() {
 
 	enableCmd.Flags().Bool("value", true, "Set to true to enable, false to disable")
 
+	installCmd.Flags().StringP("manager", "m", "os", "The package manager you want to install a package with. (Options: os|homebrew|pipx|flatpak|cargo)")
+
+	removeCmd.Flags().StringP("manager", "m", "os", "The package manager you want to remove a package with. (Options: os|homebrew|pipx|flatpak|cargo)")
+
+	searchCmd.Flags().StringP("manager", "m", "", "The package manager you want to search a package with. (Options: os|homebrew|flatpak)")
+
 	packageCmd.AddCommand(addCmd, deleteCmd, showCmd, enableCmd)
-	rootCmd.AddCommand(packageCmd, searchCmd)
+	rootCmd.AddCommand(packageCmd, searchCmd, installCmd, removeCmd)
 }
 
 func initConfig() {
@@ -70,57 +55,3 @@ func initConfig() {
 		os.Exit(1)
 	}
 }
-
-func displayResults(results []string, manager string) {
-	if len(results) == 0 {
-		fmt.Printf("No results found in %s\n", manager)
-		return
-	}
-	for _, result := range results {
-		fmt.Printf("- %s\n", result)
-	}
-}
-
-func searchPackage(packageName, manager string) []string {
-	switch manager {
-	case "brew":
-		cmd := exec.Command("brew", "search", packageName)
-		packages, err := cmd.Output()
-		if err != nil {
-			log.Printf("error fetching %s packages: %v", manager, err)
-		}
-		packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
-		return packageList
-	case "os":
-		opSys, err := getLinuxDistribution()
-		if err != nil {
-			log.Printf("Error getting OS information: %v", err)
-			return []string{}
-		}
-
-		cmdParts := strings.Fields(opSys.SearchCommand)
-		if len(cmdParts) == 0 {
-			log.Printf("Invalid search command for OS package manager")
-			return []string{}
-		}
-
-		cmd := exec.Command(cmdParts[0], append(cmdParts[1:], packageName)...)
-		packages, err := cmd.Output()
-		if err != nil {
-			log.Printf("Error fetching %s packages: %v", manager, err)
-			return []string{}
-		}
-
-		packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
-		return packageList
-	case "flatpak":
-		cmd := exec.Command("flatpak", "search", packageName)
-		packages, err := cmd.Output()
-		if err != nil {
-			log.Printf("error fetching %s packages: %v", manager, err)
-		}
-		packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
-		return packageList
-	}
-	return []string{"Beispielpaket 1", "Beispielpaket 2"} // Platzhalter
-}

flatpak.go

@@ -87,3 +87,12 @@ func (f *FlatpakManager) InstallPackage(pkg string) error {
 	cmd := execCommand("flatpak", "install", "-y", pkg)
 	return cmd.Run()
 }
+
+func (f *FlatpakManager) RemovePackage(pkg string) error {
+	cmd := execCommand("flatpak", "uninstall", pkg)
+	return cmd.Run()
+}
+
+func (f *FlatpakManager) SearchPackage(pkg string) []string {
+	return []string{}
+}

golang.go

@@ -34,3 +34,12 @@ func (g *GolangManager) InstallPackage(pkg string) error {
 	cmd := execCommand("go", "install", pkg+"@latest")
 	return cmd.Run()
 }
+
+func (g *GolangManager) RemovePackage(pkg string) error {
+	cmd := execCommand("go", "uninstall", pkg)
+	return cmd.Run()
+}
+
+func (g *GolangManager) SearchPackage(pkg string) []string {
+	return []string{}
+}

homebrew.go

@@ -41,3 +41,12 @@ func (h *HomebrewManager) InstallPackage(pkg string) error {
 	cmd := execCommand("brew", "install", pkg)
 	return cmd.Run()
 }
+
+func (h *HomebrewManager) RemovePackage(pkg string) error {
+	cmd := execCommand("brew", "uninstall", pkg)
+	return cmd.Run()
+}
+
+func (h *HomebrewManager) SearchPackage(pkg string) []string {
+	return []string{}
+}

install_cmd.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"log"
+
+	"github.com/spf13/cobra"
+)
+
+var installCmd = &cobra.Command{
+	Use:   "install [package_name]",
+	Short: "Install a package with the specified package manager",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		packageName := args[0]
+		managerName, _ := cmd.Flags().GetString("manager")
+		var manager PackageManager
+		switch managerName {
+		case "os":
+			opSys, err := getLinuxDistribution()
+			if err != nil {
+				log.Printf("error getting OS information: %v", err)
+			}
+			sudoPassword, err := getSudoPassword()
+			if err != nil {
+				log.Fatal(err)
+			}
+			osManager := NewOSManager(opSys, sudoPassword, []string{packageName})
+			if err := osManager.Install([]string{packageName}); err != nil {
+				log.Printf("error: %v\n", err)
+			}
+		case "homebrew":
+			manager = &HomebrewManager{}
+		case "cargo":
+			manager = &CargoManager{}
+		case "pipx":
+			manager = &PipxManager{}
+		case "flatpak":
+			manager = &FlatpakManager{}
+		default:
+		}
+		if err := manager.InstallPackage(packageName); err != nil {
+			log.Printf("error: %v\n", err)
+		}
+	},
+}

osinfo.go

@@ -48,13 +48,25 @@ func (o *OSManager) InstallSpecialSoftware() error {
 	return o.Model.installSpecialSoftware()
 }
 
+func (o *OSManager) removePackage(pkg string) error {
+	fullCmd := fmt.Sprintf("%s %s", o.OS.RemoveCommand, pkg)
+	command := execCommand("sudo", "-S", "sh", "-c", fullCmd)
+	command.Stdin = strings.NewReader(o.SudoPassword + "\n")
+	return command.Run()
+}
+
+func (o *OSManager) SearchPackage(pkg string) []string {
+	return []string{}
+}
+
 type OS struct {
 	ID             string
 	Name           string
 	Version        string
 	PackageManager string
 	InstallCommand string
-	SearchCommand  string // TODO: has to be implemented
+	SearchCommand  string
+	RemoveCommand  string
 }
 
 func parseOsRelease(osRelease string) *OS {
@@ -166,6 +178,22 @@ func (os *OS) getSearchCommand() error {
 	}
 }
 
+func (os *OS) getDeleteCommand() error {
+	switch os.PackageManager {
+	case "apt":
+		os.RemoveCommand = "apt remove"
+		return nil
+	case "pacman":
+		os.RemoveCommand = "pacman -R"
+		return nil
+	case "dnf":
+		os.RemoveCommand = "dnf remove"
+		return nil
+	default:
+		return fmt.Errorf("no install command found for package manager: %s", os.ID)
+	}
+}
+
 func installBuildEssentials(os *OS, sudoPassword string) error {
 	var command string
 	switch os.PackageManager {

packagemanager.go

@@ -4,5 +4,7 @@ type PackageManager interface {
 	Install(packages []string) error
 	InstallPackage(pkg string) error
 	InstallManager() error
+	RemovePackage(pkg string) error
+	SearchPackage(pkg string) []string
 	Name() string
 }

pipx.go

@@ -35,3 +35,12 @@ func (p *PipxManager) InstallPackage(pkg string) error {
 	cmd := execCommand("pipx", "install", pkg)
 	return cmd.Run()
 }
+
+func (p *PipxManager) RemovePackage(pkg string) error {
+	cmd := execCommand("pipx", "uninstall", pkg)
+	return cmd.Run()
+}
+
+func (p *PipxManager) SearchPackage(pkg string) []string {
+	return []string{}
+}

remove_cmd.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"log"
+
+	"github.com/spf13/cobra"
+)
+
+var removeCmd = &cobra.Command{
+	Use:   "remove [package_name]",
+	Short: "Remove a package with the specified package manager",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		packageName := args[0]
+		managerName, _ := cmd.Flags().GetString("manager")
+		var manager PackageManager
+		switch managerName {
+		case "os":
+			opSys, err := getLinuxDistribution()
+			if err != nil {
+				log.Printf("error getting OS information: %v", err)
+			}
+			sudoPassword, err := getSudoPassword()
+			if err != nil {
+				log.Fatal(err)
+			}
+			osManager := NewOSManager(opSys, sudoPassword, []string{packageName})
+			if err := osManager.Install([]string{packageName}); err != nil {
+				log.Printf("error: %v\n", err)
+			}
+		case "homebrew":
+			manager = &HomebrewManager{}
+		case "cargo":
+			manager = &CargoManager{}
+		case "pipx":
+			manager = &PipxManager{}
+		case "flatpak":
+			manager = &FlatpakManager{}
+		default:
+		}
+		if err := manager.RemovePackage(packageName); err != nil {
+			log.Printf("error: %v\n", err)
+		}
+	},
+}

search_cmd.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var searchCmd = &cobra.Command{
+	Use:   "search [package_name]",
+	Short: "Search for a package across package managers (will search in os|flatpak|homebrew)",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		packageName := args[0]
+		managerName, _ := cmd.Flags().GetString("manager")
+		// var manager PackageManager
+		if managerName == "" {
+			managers := []string{"brew", "os", "flatpak"}
+
+			for _, manager := range managers {
+				fmt.Printf("Searching in %s:\n", manager)
+				results := searchPackage(packageName, manager)
+				displayResults(results, manager)
+				fmt.Println()
+			}
+		}
+	},
+}
+
+func displayResults(results []string, manager string) {
+	if len(results) == 0 {
+		fmt.Printf("No results found in %s\n", manager)
+		return
+	}
+	for _, result := range results {
+		fmt.Printf("- %s\n", result)
+	}
+}
+
+func searchPackage(packageName, manager string) []string {
+	switch manager {
+	case "brew":
+		cmd := execCommand("brew", "search", packageName)
+		packages, err := cmd.Output()
+		if err != nil {
+			log.Printf("error fetching %s packages: %v", manager, err)
+		}
+		packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
+		return packageList
+	case "os":
+		opSys, err := getLinuxDistribution()
+		if err != nil {
+			log.Printf("Error getting OS information: %v", err)
+			return []string{}
+		}
+
+		cmdParts := strings.Fields(opSys.SearchCommand)
+		if len(cmdParts) == 0 {
+			log.Printf("Invalid search command for OS package manager")
+			return []string{}
+		}
+
+		cmd := execCommand(cmdParts[0], append(cmdParts[1:], packageName)...)
+		packages, err := cmd.Output()
+		if err != nil {
+			log.Printf("Error fetching %s packages: %v", manager, err)
+			return []string{}
+		}
+
+		packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
+		return packageList
+	case "flatpak":
+		cmd := execCommand("flatpak", "search", packageName)
+		packages, err := cmd.Output()
+		if err != nil {
+			log.Printf("error fetching %s packages: %v", manager, err)
+		}
+		packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
+		return packageList
+	}
+	return []string{}
+}