fix: flag parsing

Author: blurfx

executor.go

@@ -4,55 +4,81 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"strings"
 )
 
-func PassThrough(args ...string) error {
-	packageManager, err := DetectPackageManager()
+func ExecuteTranslatedCommand(pm PackageManager, translated *TranslatedCommand) error {
+	// Build the final command
+	finalArgs := append(translated.Command, translated.Flags...)
+	finalArgs = append(finalArgs, translated.Args...)
+
+	fmt.Println("finalArgs", finalArgs)
+	// Execute the main command
+	err := executeCommand(string(pm), finalArgs...)
 	if err != nil {
 		return err
 	}
 
-	cmd := exec.Command(string(packageManager), args...)
-
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	return cmd.Run()
-}
+	fmt.Println("translated.Args", translated.Args)
+	// Handle @types packages if needed
+	typesToInstall := []string{}
 
-func Exec(command CommandAlias, args ...string) error {
-	return ExecWithFlag(command, []flagAlias{}, args...)
-}
+	for _, pkg := range translated.Args {
+		// Skip if already a @types package
+		if strings.HasPrefix(pkg, "@types/") {
+			continue
+		}
 
-func ExecWithFlag(command CommandAlias, flags []flagAlias, args ...string) error {
-	packageManager, err := DetectPackageManager()
+		// Check if the package already has types
+		if IsTypedPackage(pkg) {
+			continue
+		}
 
-	if err != nil {
-		return err
+		// Check if @types package exists
+		typesPackage := "@types/" + pkg
+		exists, _ := CheckPackageExists(typesPackage)
+		if exists {
+			typesToInstall = append(typesToInstall, typesPackage)
+		}
 	}
 
-	flagArgs := make([]string, len(flags))
-	for i, flag := range flags {
-		switch packageManager {
+	// Install @types packages as dev dependencies
+	if len(typesToInstall) > 0 {
+		devCommand := []string{}
+		devFlag := []string{}
+
+		switch pm {
 		case PackageManagerNpm:
-			flagArgs[i] = flag[PackageManagerNpm][0]
+			devCommand = []string{"install"}
+			devFlag = []string{"--save-dev"}
 		case PackageManagerYarn:
-			flagArgs[i] = flag[PackageManagerYarn][0]
+			devCommand = []string{"add"}
+			devFlag = []string{"--dev"}
 		case PackageManagerPnpm:
-			flagArgs[i] = flag[PackageManagerPnpm][0]
+			devCommand = []string{"add"}
+			devFlag = []string{"--save-dev"}
 		case PackageManagerBun:
-			flagArgs[i] = flag[PackageManagerBun][0]
-		default:
-			return fmt.Errorf("unknown package manager: %s", packageManager)
+			devCommand = []string{"add"}
+			devFlag = []string{"--dev"}
+		}
+
+		typesArgs := append(devCommand, devFlag...)
+		typesArgs = append(typesArgs, typesToInstall...)
+
+		err = executeCommand(string(pm), typesArgs...)
+		if err != nil {
+			// Don't fail if @types installation fails
+			fmt.Fprintf(os.Stderr, "Warning: Failed to install @types packages: %v\n", err)
 		}
 	}
 
-	cmd := exec.Command(string(packageManager), append(command[packageManager], append(flagArgs, args...)...)...)
+	return nil
+}
 
+func executeCommand(command string, args ...string) error {
+	cmd := exec.Command(command, args...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-
 	return cmd.Run()
 }

flags.go

@@ -1,11 +1,5 @@
 package main
 
-import (
-	"strings"
-
-	"github.com/spf13/pflag"
-)
-
 type flagAlias map[PackageManager][]string
 
 type flags struct {
@@ -48,43 +42,3 @@ var Flags = flags{
 		PackageManagerBun:  []string{"--exact"},
 	},
 }
-
-func isFlag(arg string) (bool, bool) {
-	if strings.HasPrefix(arg, "--") {
-		return true, false
-	}
-	if strings.HasPrefix(arg, "-") {
-		return true, true
-	}
-	return false, false
-}
-
-func filterFlags(args []string, flags *pflag.FlagSet) []string {
-	filteredArgs := []string{}
-
-	for i := 0; i < len(args); {
-		arg := args[i]
-
-		if ok, isShorthand := isFlag(arg); ok {
-			var flag *pflag.Flag
-			if isShorthand {
-				flag = flags.ShorthandLookup(strings.TrimLeft(arg, "-"))
-			} else {
-				flag = flags.Lookup(strings.TrimLeft(arg, "-"))
-			}
-			if flag != nil {
-				// If the flag has a value (e.g. --flag=value or -f value), skip it
-				if flag.Value.Type() != "bool" && i+1 < len(args) {
-					i++
-				}
-			} else {
-				filteredArgs = append(filteredArgs, arg)
-			}
-		} else {
-			filteredArgs = append(filteredArgs, arg)
-		}
-		i++
-	}
-
-	return filteredArgs
-}

go.mod

@@ -11,5 +11,5 @@ require golang.org/x/sys v0.33.0 // indirect
 
 require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.5
+	github.com/spf13/pflag v1.0.5 // indirect
 )

main.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"strings"
 
 	"github.com/spf13/cobra"
 )
@@ -31,173 +30,16 @@ func main() {
 				Exec(Commands.Run, script.Name)
 				return
 			}
-			if IsBuiltInCommand(packageManager, args...) {
-				if err := PassThrough(args...); err != nil {
-					fmt.Fprintln(os.Stderr, err)
-				}
-				return
-			}
-			allArgs := append([]string{"run"}, args...)
-			if err := PassThrough(allArgs...); err != nil {
-				fmt.Fprintln(os.Stderr, err)
-			}
-		},
-		Args: cobra.ArbitraryArgs,
-	}
-
-	addCmd := &cobra.Command{
-		Use:     "add <package name>",
-		Aliases: []string{"i", "install"},
-		Short:   "Add dependency if package name is given.",
-		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) == 0 {
-				log.Fatalf("No package name given")
-			}
-
-			cmd.Flags().Parse(args)
-
-			dev := GetBoolFlag(cmd, "save-dev", "dev")
-			peer := GetBoolFlag(cmd, "save-peer", "peer")
-			optional := GetBoolFlag(cmd, "save-optional", "optional")
-			global := GetBoolFlag(cmd, "global")
-			exact := GetBoolFlag(cmd, "exact")
-			frozenLockfile := GetBoolFlag(cmd, "frozen-lockfile")
-
-			if frozenLockfile {
-				Exec(Commands.CI)
-				return
-			}
-
-			var flags []flagAlias
-			if dev {
-				flags = append(flags, Flags.Dev)
-			}
-			if peer {
-				flags = append(flags, Flags.Peer)
-			}
-			if optional {
-				flags = append(flags, Flags.Optional)
-			}
-			if global {
-				flags = append(flags, Flags.Global)
-			}
-			if exact {
-				flags = append(flags, Flags.Exact)
-			}
-			args = filterFlags(args, cmd.Flags())
-
-			ExecWithFlag(Commands.Add, flags, args...)
-
-			nonTypedPackages := []string{}
-			for _, arg := range args {
-				if !strings.HasPrefix(arg, "@types/") {
-					if IsTypedPackage(arg) {
-						continue
-					}
-					ok, _ := CheckPackageExists("@types/" + arg)
-					if !ok {
-						continue
-					}
-					nonTypedPackages = append(nonTypedPackages, "@types/"+arg)
-				}
-			}
-			if !dev && !peer && !optional && !global {
-				for _, packageName := range nonTypedPackages {
-					ExecWithFlag(Commands.Add, []flagAlias{Flags.Dev}, packageName)
-				}
-			}
-		},
-		DisableFlagParsing: true,
-	}
 
-	addCmd.Flags().BoolP("save-dev", "D", false, "install package as dev dependency")
-	addCmd.Flags().Bool("dev", false, "install package as dev dependency")
-	addCmd.Flags().MarkHidden("dev")
-	addCmd.Flags().BoolP("save-peer", "P", false, "install package as peer dependency")
-	addCmd.Flags().Bool("peer", false, "install package as peer dependency")
-	addCmd.Flags().MarkHidden("peer")
-	addCmd.Flags().BoolP("save-optional", "O", false, "install package as optional dependency")
-	addCmd.Flags().Bool("optional", false, "install package as optional dependency")
-	addCmd.Flags().MarkHidden("optional")
-	addCmd.Flags().BoolP("global", "g", false, "install package globally")
-	addCmd.Flags().BoolP("exact", "E", false, "install exact version")
-	addCmd.Flags().Bool("frozen-lockfile", false, "don't generate a lockfile and fail if an update is needed")
-	addCmd.FParseErrWhitelist = cobra.FParseErrWhitelist{UnknownFlags: true}
-
-	installCmd := &cobra.Command{
-		Use:     "install [package name]",
-		Aliases: []string{"i"},
-		Short:   "Add dependency if package name is given. Otherwise, install the package",
-		Run: func(cmd *cobra.Command, args []string) {
-			frozenLockfile, _ := cmd.Flags().GetBool("frozen-lockfile")
+			translator := NewCommandTranslator(packageManager)
+			translated := translator.Translate(args)
 
-			if frozenLockfile {
-				Exec(Commands.CI)
-				return
-			}
-
-			if len(args) > 0 {
-				addCmd.Run(cmd, args)
-			} else {
-				Exec(Commands.Install)
-			}
-		},
-		DisableFlagParsing: true,
-	}
-
-	installCmd.Flags().Bool("frozen-lockfile", false, "don't generate a lockfile and fail if an update is needed")
-	installCmd.FParseErrWhitelist = cobra.FParseErrWhitelist{UnknownFlags: true}
-
-	uninstallCmd := &cobra.Command{
-		Use:     "uninstall <package name>",
-		Aliases: []string{"rm", "remove", "un"},
-		Short:   "Uninstall a package",
-		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) == 0 {
-				log.Fatalf("No package name given")
-			}
-
-			Exec(Commands.Uninstall, args...)
-		},
-		DisableFlagParsing: true,
-	}
-	uninstallCmd.FParseErrWhitelist = cobra.FParseErrWhitelist{UnknownFlags: true}
-
-	ciCmd := &cobra.Command{
-		Use:   "ci",
-		Short: "CI command",
-		Run: func(cmd *cobra.Command, args []string) {
-			Exec(Commands.CI)
-		},
-	}
-	ciCmd.FParseErrWhitelist = cobra.FParseErrWhitelist{UnknownFlags: true}
-
-	runCmd := &cobra.Command{
-		Use:   "run",
-		Short: "Run command",
-		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) == 0 {
-				script, err := showScriptPrompt()
-				if err != nil {
-					if err.Error() != "cancelled" {
-						fmt.Fprintln(os.Stderr, err)
-					}
-					return
-				}
-				Exec(Commands.Run, script.Name)
-			} else {
-				Exec(Commands.Run, args...)
+			if err := ExecuteTranslatedCommand(packageManager, translated); err != nil {
+				fmt.Fprintln(os.Stderr, err)
 			}
 		},
-		DisableFlagParsing: true,
+		Args: cobra.ArbitraryArgs,
 	}
-	runCmd.FParseErrWhitelist = cobra.FParseErrWhitelist{UnknownFlags: true}
-
-	rootCmd.AddCommand(installCmd)
-	rootCmd.AddCommand(addCmd)
-	rootCmd.AddCommand(uninstallCmd)
-	rootCmd.AddCommand(ciCmd)
-	rootCmd.AddCommand(runCmd)
 
 	if err := rootCmd.Execute(); err != nil {
 		log.Fatal(err)

npm.go

@@ -14,11 +14,12 @@ func CheckPackageExists(packageName string) (bool, error) {
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode == http.StatusOK {
+	switch resp.StatusCode {
+	case http.StatusOK:
 		return true, nil
-	} else if resp.StatusCode == http.StatusNotFound {
+	case http.StatusNotFound:
 		return false, nil
-	} else {
+	default:
 		return false, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
 	}
 }
@@ -35,7 +36,7 @@ type PackageInfo struct {
 
 func IsTypedPackage(packageName string) bool {
 	url := fmt.Sprintf("https://registry.npmjs.org/%s", packageName)
-	resp, err := http.Head(url)
+	resp, err := http.Get(url)
 	if err != nil {
 		return false
 	}