fix(npm): handle multiple packages and flag parsing correctly

- Fixes issue where only the first package was scanned; now all packages in install command are parsed and processed.
- Correctly separates flags (e.g., --save-dev) from package names to avoid treating them as packages.
- Applies same fixes to both npm and pnpm flows.
- Updated wrapper to scan all packages before installing, maintaining original CLI behavior.

cmd/npm/npm.go

@@ -24,13 +24,30 @@ func NewNpmCommand() *cobra.Command {
 			}
 
 			if len(args) >= 2 && utils.IsInstallCommand(string(registry.RegistryNPM), args[0]) {
+<<<<<<< HEAD
 				pmw := wrapper.NewPackageManagerWrapper(registry.RegistryNPM)
 				pmw.Action = args[0]
 				pmw.PackageName = args[1]
-
+=======
-				if err := pmw.Wrap(); err != nil {
+				if err := utils.ValidateEnvVars(); err != nil {
-					os.Exit(1)
+					return err
 				}
+
+				// Parse arguments to separate flags and packages
+				flags, packages := utils.ParseNpmInstallArgs(args[1:])
+>>>>>>> 5d0d78d (fix(npm): handle multiple packages and flag parsing correctly)
+
+				// If no packages specified, just pass through to npm
+				if len(packages) == 0 {
+					return utils.ExecCmd(execPath, args, []string{})
+				}
+
+				// Create single wrapper instance for all packages
+				pmw := wrapper.NewPackageManagerWrapper(registry.RegistryNPM, flags, packages, args[0])
+				if err := pmw.Wrap(); err != nil {
+					return err
+				}
+
 				return nil
 			}
 

cmd/npm/pnpm.go

@@ -17,20 +17,38 @@ func NewPnpmCommand() *cobra.Command {
 		Short:              "Scan packages from npm registry",
 		DisableFlagParsing: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			execPath, err := utils.GetExecutablePath(string(registry.RegistryPNPM))
+			execPath, err := utils.GetExecutablePath(string(registry.RegistryNPM))
 			if err != nil {
-				fmt.Fprintf(os.Stderr, "pnpm not found: %v\n", err)
+				fmt.Fprintf(os.Stderr, "npm not found: %v\n", err)
 				return err
 			}
 
+<<<<<<< HEAD
 			if len(args) >= 2 && utils.IsInstallCommand(string(registry.RegistryPNPM), args[0]) {
 				pmw := wrapper.NewPackageManagerWrapper(registry.RegistryPNPM)
 				pmw.Action = args[0]
 				pmw.PackageName = args[1]
-
+=======
-				if err := pmw.Wrap(); err != nil {
+			if len(args) >= 2 && utils.IsInstallCommand(string(registry.RegistryNPM), args[0]) {
-					os.Exit(1)
+				if err := utils.ValidateEnvVars(); err != nil {
+					return err
 				}
+
+				// Parse arguments to separate flags and packages
+				flags, packages := utils.ParseNpmInstallArgs(args[1:])
+>>>>>>> 5d0d78d (fix(npm): handle multiple packages and flag parsing correctly)
+
+				// If no packages specified, just pass through to npm
+				if len(packages) == 0 {
+					return utils.ExecCmd(execPath, args, []string{})
+				}
+
+				// Create single wrapper instance for all packages
+				pmw := wrapper.NewPackageManagerWrapper(registry.RegistryNPM, flags, packages, args[0])
+				if err := pmw.Wrap(); err != nil {
+					return err
+				}
+
 				return nil
 			}
 

pkg/common/utils/npm.go

@@ -0,0 +1,64 @@
+package utils
+
+import (
+	"fmt"
+	"strings"
+)
+
+// ParseNpmInstallArgs parses npm install command arguments and returns
+// separated flags and packages. It expects args to include the full command
+// including "npm" and "install" at the start
+func ParseNpmInstallArgs(args []string) ([]string, []string) {
+	var flags []string
+	var packages []string
+
+	for _, arg := range args {
+		if strings.HasPrefix(arg, "-") {
+			flags = append(flags, arg)
+		} else {
+			packages = append(packages, arg)
+		}
+	}
+	return flags, packages
+}
+
+func CleanVersion(version string) string {
+	version = strings.TrimPrefix(version, "^")
+	version = strings.TrimPrefix(version, "~")
+	if version == "*" {
+		return "latest"
+	}
+	return version
+}
+
+func ParsePackageInfo(input string) (packageName, version string, err error) {
+	if input == "" {
+		return "", "", fmt.Errorf("package info cannot be empty")
+	}
+	input = strings.TrimSpace(input)
+
+	if strings.HasPrefix(input, "@") {
+		lastAtIndex := strings.LastIndex(input, "@")
+		if lastAtIndex > 0 {
+			packageName = strings.TrimSpace(input[:lastAtIndex])
+			version = strings.TrimSpace(input[lastAtIndex+1:])
+			return packageName, version, nil
+		}
+		// If no version specifier, return the whole input as package name
+		return strings.TrimSpace(input), "", nil
+	}
+
+	pkg := strings.Split(input, "@")
+	if len(pkg) == 2 {
+		packageName = strings.TrimSpace(pkg[0])
+		version = strings.TrimSpace(pkg[1])
+		return packageName, version, nil
+	}
+
+	if len(pkg) == 1 {
+		packageName = strings.TrimSpace(pkg[0])
+		return packageName, "", nil
+	}
+
+	return "", "", fmt.Errorf("invalid format: expected 'package' OR 'package@version', got '%s'", input)
+}

pkg/common/utils/utils.go

@@ -1,51 +1,5 @@
 package utils
 
-import (
-	"fmt"
-	"strings"
-)
-
-func CleanVersion(version string) string {
-	version = strings.TrimPrefix(version, "^")
-	version = strings.TrimPrefix(version, "~")
-	if version == "*" {
-		return "latest"
-	}
-	return version
-}
-
-func ParsePackageInfo(input string) (packageName, version string, err error) {
-	if input == "" {
-		return "", "", fmt.Errorf("package info cannot be empty")
-	}
-	input = strings.TrimSpace(input)
-
-	if strings.HasPrefix(input, "@") {
-		lastAtIndex := strings.LastIndex(input, "@")
-		if lastAtIndex > 0 {
-			packageName = strings.TrimSpace(input[:lastAtIndex])
-			version = strings.TrimSpace(input[lastAtIndex+1:])
-			return packageName, version, nil
-		}
-		// If no version specifier, return the whole input as package name
-		return strings.TrimSpace(input), "", nil
-	}
-
-	pkg := strings.Split(input, "@")
-	if len(pkg) == 2 {
-		packageName = strings.TrimSpace(pkg[0])
-		version = strings.TrimSpace(pkg[1])
-		return packageName, version, nil
-	}
-
-	if len(pkg) == 1 {
-		packageName = strings.TrimSpace(pkg[0])
-		return packageName, "", nil
-	}
-
-	return "", "", fmt.Errorf("invalid format: expected 'package' OR 'package@version', got '%s'", input)
-}
-
 func IsInstallCommand(pkgManager, cmd string) bool {
 	validActions := map[string]map[string]bool{
 		"npm": {

pkg/wrapper/npm_base.go

@@ -17,33 +17,50 @@ import (
 )
 
 type PackageManagerWrapper struct {
-	RegistryType registry.RegistryType
+	RegistryType   registry.RegistryType
-	Action       string
+	Flags          []string
-	PackageName  string
+	Action         string
+	PackageNames   []string
+	currentPackage string
 }
 
-func NewPackageManagerWrapper(registryType registry.RegistryType) *PackageManagerWrapper {
+func NewPackageManagerWrapper(registryType registry.RegistryType, flags []string, packageNames []string, action string) *PackageManagerWrapper {
 	return &PackageManagerWrapper{
 		RegistryType: registryType,
+		PackageNames: packageNames,
+		Flags:        flags,
+		Action:       action,
 	}
 }
 
 func (pmw *PackageManagerWrapper) Wrap() error {
-	ui.StartProgressWriter()
+	if len(pmw.PackageNames) == 0 {
-	var DefaultProgressTotal = 5
+		return fmt.Errorf("no packages specified")
-	progressTracker := ui.TrackProgress(fmt.Sprintf("Scanning %s ", pmw.PackageName), DefaultProgressTotal)
-	if pmw.PackageName == "" {
-		return fmt.Errorf("package name cannot be empty")
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
 	defer cancel()
 
-	if err := pmw.scanAndInstall(ctx, progressTracker); err != nil {
+	// Scan all packages first
+	for _, pkg := range pmw.PackageNames {
+		ui.StartProgressWriter()
+		var DefaultProgressTotal = 1
+		pmw.currentPackage = pkg
+		progressTracker := ui.TrackProgress(fmt.Sprintf("Scanning %s", pkg), DefaultProgressTotal)
+
+		if err := pmw.scanAndInstall(ctx, progressTracker); err != nil {
+			return err
+		}
+
+		ui.StopProgressWriter()
+	}
+
+	// Execute installation after all scans complete
+	if err := pmw.executeInstallation(); err != nil {
 		return err
 	}
 
-	log.Infof("Successfully installed %s", pmw.PackageName)
+	log.Infof("Successfully installed all packages")
 	return nil
 }
 
@@ -54,7 +71,7 @@ func (pmw *PackageManagerWrapper) scanAndInstall(ctx context.Context, progressTr
 		return err
 	}
 
-	name, version, err := utils.ParsePackageInfo(pmw.PackageName)
+	name, version, err := utils.ParsePackageInfo(pmw.currentPackage)
 	if err != nil {
 		return err
 	}
@@ -64,7 +81,7 @@ func (pmw *PackageManagerWrapper) scanAndInstall(ctx context.Context, progressTr
 		if err != nil {
 			return err
 		}
-		pmw.PackageName = fmt.Sprintf("%s@%s", name, version)
+		pmw.currentPackage = fmt.Sprintf("%s@%s", name, version)
 	}
 
 	// Get dependencies with progress tracking
@@ -76,13 +93,13 @@ func (pmw *PackageManagerWrapper) scanAndInstall(ctx context.Context, progressTr
 		return err
 	}
 
-	// We know the total deps, set progress for analysis phase
+	// Set progress for analysis phase
 	ui.IncrementTrackerTotal(progressTracker, int64(len(deps)))
 	if err := pmw.analyzeDependencies(ctx, deps, progressTracker); err != nil {
 		return err
 	}
 
-	return pmw.executeInstallation()
+	return nil
 }
 
 func (pmw *PackageManagerWrapper) resolveLatestVersion(ctx context.Context, fetcher registry.Fetcher, name string) (string, error) {
@@ -143,7 +160,9 @@ func (pmw *PackageManagerWrapper) executeInstallation() error {
 		return fmt.Errorf("%s not found: %w", pmw.RegistryType, err)
 	}
 
-	cmdArgs := []string{pmw.Action, pmw.PackageName}
+	cmdArgs := []string{pmw.Action}
+	cmdArgs = append(cmdArgs, pmw.Flags...)
+	cmdArgs = append(cmdArgs, pmw.PackageNames...)
 	if err = utils.ExecCmd(execPath, cmdArgs, []string{}); err != nil {
 		return fmt.Errorf("failed to execute %s command: %w", pmw.RegistryType, err)
 	}