feat: add guided setup command

cmd/root.go

@@ -22,11 +22,11 @@ import (
 	flagscmd "github.com/launchdarkly/ldcli/cmd/flags"
 	logincmd "github.com/launchdarkly/ldcli/cmd/login"
 	memberscmd "github.com/launchdarkly/ldcli/cmd/members"
-	sdkactivecmd "github.com/launchdarkly/ldcli/cmd/sdk_active"
 	resourcecmd "github.com/launchdarkly/ldcli/cmd/resources"
+	sdkactivecmd "github.com/launchdarkly/ldcli/cmd/sdk_active"
+	setupcmd "github.com/launchdarkly/ldcli/cmd/setup"
 	signupcmd "github.com/launchdarkly/ldcli/cmd/signup"
 	sourcemapscmd "github.com/launchdarkly/ldcli/cmd/sourcemaps"
-	symbolscmd "github.com/launchdarkly/ldcli/cmd/symbols"
 	whoamicmd "github.com/launchdarkly/ldcli/cmd/whoami"
 	"github.com/launchdarkly/ldcli/internal/analytics"
 	"github.com/launchdarkly/ldcli/internal/config"
@@ -37,6 +37,7 @@ import (
 	"github.com/launchdarkly/ldcli/internal/members"
 	"github.com/launchdarkly/ldcli/internal/projects"
 	"github.com/launchdarkly/ldcli/internal/resources"
+	"github.com/launchdarkly/ldcli/internal/setup"
 )
 
 type APIClients struct {
@@ -46,6 +47,8 @@ type APIClients struct {
 	MembersClient      members.Client
 	ProjectsClient     projects.Client
 	ResourcesClient    resources.Client
+	Detector           setup.Detector
+	Installer          setup.Installer
 }
 
 type Command interface {
@@ -126,23 +129,26 @@ func NewRootCommand(
 		Long:    "LaunchDarkly CLI to control your feature flags",
 		Version: version,
 		PersistentPreRun: func(cmd *cobra.Command, args []string) {
-			// disable required flags when running certain commands
+			// Skip the global --access-token required-flag check for commands
+			// that don't need an API token. We clear the annotation on the
+			// specific flag instead of setting DisableFlagParsing, which would
+			// also suppress validation for the subcommand's own required flags.
 			for _, name := range []string{
 				"completion",
 				"config",
 				"help",
 				"login",
+				"setup",
 				"signup",
 				"whoami",
 			} {
-				if cmd.HasParent() && cmd.Parent().Name() == name {
-					cmd.DisableFlagParsing = true
-				}
-				if cmd.Name() == name {
-					cmd.DisableFlagParsing = true
+				if cmd.Name() == name || (cmd.HasParent() && cmd.Parent().Name() == name) {
+					if f := cmd.Flags().Lookup(cliflags.AccessTokenFlag); f != nil {
+						delete(f.Annotations, cobra.BashCompOneRequiredFlag)
+					}
+					break
 				}
 			}
-
 		},
 		Annotations: make(map[string]string),
 		// Handle errors differently based on type.
@@ -254,13 +260,31 @@ func NewRootCommand(
 
 	configCmd := configcmd.NewConfigCmd(configService, analyticsTrackerFn)
 	cmd.AddCommand(configCmd.Cmd())
-	cmd.AddCommand(NewQuickStartCmd(analyticsTrackerFn, clients.EnvironmentsClient, clients.FlagsClient))
+	detector := clients.Detector
+	if detector == nil {
+		detector = setup.FileDetector{}
+	}
+	installer := clients.Installer
+	if installer == nil {
+		installer = setup.PackageInstaller{}
+	}
+	cmd.AddCommand(setupcmd.NewSetupCmd(
+		analyticsTrackerFn,
+		clients.ResourcesClient,
+		clients.FlagsClient,
+		detector,
+		installer,
+	))
+	quickStartCmd := NewQuickStartCmd(analyticsTrackerFn, clients.EnvironmentsClient, clients.FlagsClient)
+	quickStartCmd.Use = "quickstart"
+	quickStartCmd.Hidden = true
+	quickStartCmd.Deprecated = "use 'ldcli setup' for the new guided setup experience"
+	cmd.AddCommand(quickStartCmd)
 	cmd.AddCommand(logincmd.NewLoginCmd(clients.ResourcesClient))
 	cmd.AddCommand(signupcmd.NewSignupCmd(analyticsTrackerFn))
 	cmd.AddCommand(resourcecmd.NewResourcesCmd())
 	cmd.AddCommand(devcmd.NewDevServerCmd(clients.ResourcesClient, analyticsTrackerFn, clients.DevClient))
 	cmd.AddCommand(sourcemapscmd.NewSourcemapsCmd(clients.ResourcesClient, analyticsTrackerFn))
-	cmd.AddCommand(symbolscmd.NewSymbolsCmd(clients.ResourcesClient, analyticsTrackerFn))
 	cmd.AddCommand(whoamicmd.NewWhoAmICmd(clients.ResourcesClient))
 	resourcecmd.AddAllResourceCmds(cmd, clients.ResourcesClient, analyticsTrackerFn)
 

cmd/setup/detect.go

@@ -0,0 +1,62 @@
+package setup
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/launchdarkly/ldcli/cmd/cliflags"
+	"github.com/launchdarkly/ldcli/internal/setup"
+)
+
+const pathFlag = "path"
+
+func newDetectCmd(detector setup.Detector) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:    "detect",
+		Short:  "Detect language, framework, and recommended SDK for a project",
+		Hidden: true,
+		RunE:   runDetect(detector),
+	}
+
+	cmd.Flags().String(pathFlag, "", "Path to the project directory (defaults to current directory)")
+
+	return cmd
+}
+
+func runDetect(detector setup.Detector) func(*cobra.Command, []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		dir, _ := cmd.Flags().GetString(pathFlag)
+		if dir == "" {
+			var err error
+			dir, err = os.Getwd()
+			if err != nil {
+				return err
+			}
+		}
+
+		result, err := detector.Detect(dir)
+		if err != nil {
+			return err
+		}
+
+		outputKind := cliflags.GetOutputKind(cmd)
+		if outputKind == "json" {
+			data, _ := json.Marshal(result)
+			fmt.Fprintln(cmd.OutOrStdout(), string(data))
+			return nil
+		}
+
+		fmt.Fprintf(cmd.OutOrStdout(), "Language: %s\n", result.Language)
+		if result.Framework != "" {
+			fmt.Fprintf(cmd.OutOrStdout(), "Framework: %s\n", result.Framework)
+		}
+		fmt.Fprintf(cmd.OutOrStdout(), "Package Manager: %s\n", result.PackageManager)
+		fmt.Fprintf(cmd.OutOrStdout(), "Recommended SDK: %s\n", result.SDKID)
+		fmt.Fprintf(cmd.OutOrStdout(), "Entry Point: %s\n", result.EntryPoint)
+
+		return nil
+	}
+}

cmd/setup/init.go

@@ -0,0 +1,86 @@
+package setup
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/launchdarkly/ldcli/cmd/cliflags"
+	"github.com/launchdarkly/ldcli/internal/setup"
+)
+
+func getFlag(cmd *cobra.Command, name string) string {
+	v, _ := cmd.Flags().GetString(name)
+	return v
+}
+
+const (
+	fileFlag     = "file"
+	sdkKeyFlag   = "sdk-key"
+	clientIDFlag = "client-side-id"
+	mobileFlag   = "mobile-key"
+	flagKeyFlag  = "flag-key"
+)
+
+func newInitCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:    "init",
+		Short:  "Inject LaunchDarkly SDK initialization code into a file",
+		Hidden: true,
+		RunE:   runInit(),
+	}
+
+	cmd.Flags().String(sdkIDFlag, "", "SDK identifier (e.g. node-server, react-client-sdk)")
+	_ = cmd.MarkFlagRequired(sdkIDFlag)
+
+	cmd.Flags().String(fileFlag, "", "Target file to inject initialization code into")
+	_ = cmd.MarkFlagRequired(fileFlag)
+
+	cmd.Flags().String(sdkKeyFlag, "", "Server-side SDK key")
+	cmd.Flags().String(clientIDFlag, "", "Client-side environment ID")
+	cmd.Flags().String(mobileFlag, "", "Mobile SDK key")
+	cmd.Flags().String(flagKeyFlag, "", "Feature flag key to use in the initialization example")
+
+	return cmd
+}
+
+func runInit() func(*cobra.Command, []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		sdkID, _ := cmd.Flags().GetString(sdkIDFlag)
+		filePath, _ := cmd.Flags().GetString(fileFlag)
+		cfg := setup.InitConfig{
+			SDKKey:       getFlag(cmd, sdkKeyFlag),
+			ClientSideID: getFlag(cmd, clientIDFlag),
+			MobileKey:    getFlag(cmd, mobileFlag),
+			FlagKey:      getFlag(cmd, flagKeyFlag),
+		}
+
+		initializer := setup.Initializer{}
+		result, err := initializer.InjectIntoFile(sdkID, filePath, cfg)
+		if err != nil {
+			return err
+		}
+
+		outputKind := cliflags.GetOutputKind(cmd)
+		if outputKind == "json" {
+			data, _ := json.Marshal(result)
+			fmt.Fprintln(cmd.OutOrStdout(), string(data))
+			return nil
+		}
+
+		if !result.Success {
+			if result.Snippet != "" {
+				fmt.Fprintf(cmd.OutOrStdout(), "Manual setup required for %s — add the following to %s:\n\n%s\n\n", result.SDKID, result.FilePath, result.Snippet)
+				fmt.Fprintf(cmd.OutOrStdout(), "Follow the setup guide at: %s\n", result.DocsURL)
+				return nil
+			}
+			fmt.Fprintf(cmd.OutOrStdout(), "No initialization template available for %s\n", result.SDKID)
+			fmt.Fprintf(cmd.OutOrStdout(), "Follow the setup guide at: %s\n", result.DocsURL)
+			return nil
+		}
+
+		fmt.Fprintf(cmd.OutOrStdout(), "Injected %s initialization into %s\n", result.SDKID, result.FilePath)
+		return nil
+	}
+}

cmd/setup/install.go

@@ -0,0 +1,99 @@
+package setup
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/launchdarkly/ldcli/cmd/cliflags"
+	"github.com/launchdarkly/ldcli/internal/setup"
+)
+
+const (
+	sdkIDFlag  = "sdk-id"
+	dryRunFlag = "dry-run"
+)
+
+func newInstallCmd(installer setup.Installer) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:    "install",
+		Short:  "Install the LaunchDarkly SDK package for the detected project",
+		Hidden: true,
+		RunE:   runInstall(installer),
+	}
+
+	cmd.Flags().String(pathFlag, "", "Path to the project directory (defaults to current directory)")
+	cmd.Flags().String(sdkIDFlag, "", "SDK identifier to install (e.g. node-server, react-client-sdk)")
+	_ = cmd.MarkFlagRequired(sdkIDFlag)
+	cmd.Flags().String("package-manager", "", "Package manager to use (e.g. npm, pip, go)")
+	cmd.Flags().Bool(dryRunFlag, false, "Print the install command that would run without executing it")
+
+	return cmd
+}
+
+func runInstall(installer setup.Installer) func(*cobra.Command, []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		dir, _ := cmd.Flags().GetString(pathFlag)
+		if dir == "" {
+			var err error
+			dir, err = os.Getwd()
+			if err != nil {
+				return err
+			}
+		}
+
+		sdkID, _ := cmd.Flags().GetString(sdkIDFlag)
+		pkgMgr, _ := cmd.Flags().GetString("package-manager")
+		dryRun, _ := cmd.Flags().GetBool(dryRunFlag)
+		detection := &setup.DetectResult{
+			SDKID:          sdkID,
+			PackageManager: pkgMgr,
+		}
+
+		var result *setup.InstallResult
+		if dryRun {
+			args, pkg := setup.InstallArgs(sdkID, pkgMgr)
+			result = &setup.InstallResult{
+				SDKID:   sdkID,
+				Package: pkg,
+				Command: strings.Join(args, " "),
+				DryRun:  true,
+			}
+		} else {
+			var err error
+			result, err = installer.Install(dir, detection)
+			if err != nil {
+				return err
+			}
+		}
+
+		outputKind := cliflags.GetOutputKind(cmd)
+		if outputKind == "json" {
+			data, _ := json.Marshal(result)
+			fmt.Fprintln(cmd.OutOrStdout(), string(data))
+			return nil
+		}
+
+		fmt.Fprintf(cmd.OutOrStdout(), "SDK: %s\n", result.SDKID)
+		if result.Version != "" {
+			fmt.Fprintf(cmd.OutOrStdout(), "Package: %s@%s\n", result.Package, result.Version)
+		} else {
+			fmt.Fprintf(cmd.OutOrStdout(), "Package: %s\n", result.Package)
+		}
+		if result.AlreadyInstalled {
+			fmt.Fprintln(cmd.OutOrStdout(), "Already installed — skipping install.")
+			return nil
+		}
+		fmt.Fprintf(cmd.OutOrStdout(), "Command: %s\n", result.Command)
+		if result.DryRun {
+			fmt.Fprintln(cmd.OutOrStdout(), "Dry run: command not executed")
+		} else {
+			fmt.Fprintf(cmd.OutOrStdout(), "Success: %t\n", result.Success)
+		}
+
+		return nil
+	}
+}