azd init - Combine "Create a minimal project" with "Scan current directory" option and add --minimal flag (#5280)

* Add --minimal flag to init command

* Allow user to continue initializing as minimal project when there's no detected service

* Merge next-steps.md and next-steps-alpha.md

* Do not show "Remove a detected service" when there are no detected resources

Author: JeffreyCA

cli/azd/cmd/init.go

@@ -31,7 +31,6 @@ import (
 	"github.com/azure/azure-dev/cli/azd/pkg/tools"
 	"github.com/azure/azure-dev/cli/azd/pkg/tools/git"
 	"github.com/azure/azure-dev/cli/azd/pkg/workflow"
-	"github.com/fatih/color"
 	"github.com/joho/godotenv"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -59,6 +58,7 @@ type initFlags struct {
 	location       string
 	global         *internal.GlobalCommandOptions
 	fromCode       bool
+	minimal        bool
 	up             bool
 	internal.EnvFlag
 }
@@ -99,6 +99,13 @@ func (i *initFlags) Bind(local *pflag.FlagSet, global *internal.GlobalCommandOpt
 		false,
 		"Initializes a new application from your existing code.",
 	)
+	local.BoolVarP(
+		&i.minimal,
+		"minimal",
+		"m",
+		false,
+		"Initializes a minimal project.",
+	)
 	local.BoolVarP(
 		&i.up,
 		"up",
@@ -206,28 +213,35 @@ func (i *initAction) Run(ctx context.Context) (*actions.ActionResult, error) {
 		return nil, fmt.Errorf("checking if project exists: %w", err)
 	}
 
-	var initTypeSelect initType
+	var initTypeSelect initType = initUnknown
+	initTypeCount := 0
 	if i.flags.templatePath != "" || len(i.flags.templateTags) > 0 {
-		// an explicit --template passed, always initialize from app template
+		initTypeCount++
 		initTypeSelect = initAppTemplate
 	}
-
 	if i.flags.fromCode {
-		if i.flags.templatePath != "" {
-			return nil, errors.New("only one of init modes: --template, or --from-code should be set")
-		}
+		initTypeCount++
 		initTypeSelect = initFromApp
 	}
+	if i.flags.minimal {
+		initTypeCount++
+		initTypeSelect = initFromApp // Minimal now also uses initFromApp path
+	}
 
-	if i.flags.templatePath == "" && !i.flags.fromCode && existingProject {
-		// only initialize environment when no mode is set explicitly
-		initTypeSelect = initEnvironment
+	if initTypeCount > 1 {
+		return nil, errors.New("only one of init modes: --template, --from-code, or --minimal should be set")
 	}
 
 	if initTypeSelect == initUnknown {
-		initTypeSelect, err = promptInitType(i.console, ctx)
-		if err != nil {
-			return nil, err
+		if existingProject {
+			// only initialize environment when no mode is set explicitly
+			initTypeSelect = initEnvironment
+		} else {
+			// Prompt for init type for new projects
+			initTypeSelect, err = promptInitType(i.console, ctx)
+			if err != nil {
+				return nil, err
+			}
 		}
 	}
 
@@ -277,36 +291,48 @@ func (i *initAction) Run(ctx context.Context) (*actions.ActionResult, error) {
 
 	case initFromApp:
 		tracing.SetUsageAttributes(fields.InitMethod.String("app"))
-
 		header = "Your app is ready for the cloud!"
 		followUp = "Run " + output.WithHighLightFormat("azd up") + " to provision and deploy your app to Azure.\n" +
 			"Run " + output.WithHighLightFormat("azd add") + " to add new Azure components to your project.\n" +
 			"Run " + output.WithHighLightFormat("azd infra gen") + " to generate IaC for your project to disk, " +
 			"allowing you to manually manage it.\n" +
 			"See " + output.WithHighLightFormat("./next-steps.md") + " for more information on configuring your app."
-		entries, err := os.ReadDir(azdCtx.ProjectDirectory())
-		if err != nil {
-			return nil, fmt.Errorf("reading current directory: %w", err)
+
+		envSpecified := i.flags.EnvironmentName != ""
+		initializeEnv := func() (*environment.Environment, error) {
+			return i.initializeEnv(ctx, azdCtx, templates.Metadata{})
 		}
+		initializeMinimal := func() error {
+			tracing.SetUsageAttributes(fields.InitMethod.String("project"))
+			err := i.repoInitializer.InitializeMinimal(ctx, azdCtx)
+			if err != nil {
+				return err
+			}
 
-		if len(entries) == 0 {
-			return nil, &internal.ErrorWithSuggestion{
-				Err: errors.New("no files found in the current directory"),
-				Suggestion: "Ensure you're in the directory where your app code is located and try again." +
-					" If you do not have code and would like to start with an app template, run '" +
-					output.WithHighLightFormat("azd init") + "' and select the option to " +
-					color.MagentaString("Use a template") + ".",
+			// Create env upfront only if the environment name is passed in.
+			if envSpecified {
+				_, err := initializeEnv()
+				if err != nil {
+					return err
+				}
 			}
+
+			header = "Generated azure.yaml project file."
+			followUp = "Run " + output.WithHighLightFormat("azd add") + " to add new Azure components to your project."
+			return nil
 		}
 
-		err = i.repoInitializer.InitFromApp(
-			ctx,
-			azdCtx,
-			func() (*environment.Environment, error) {
-				return i.initializeEnv(ctx, azdCtx, templates.Metadata{})
-			},
-			i.flags.EnvironmentName != "",
-		)
+		if i.flags.minimal {
+			err = initializeMinimal()
+		} else {
+			err = i.repoInitializer.InitFromApp(
+				ctx,
+				azdCtx,
+				initializeEnv,
+				initializeMinimal,
+				envSpecified,
+			)
+		}
 		if err != nil {
 			return nil, err
 		}
@@ -318,24 +344,6 @@ func (i *initAction) Run(ctx context.Context) (*actions.ActionResult, error) {
 
 		header = fmt.Sprintf("Initialized environment %s.", env.Name())
 		followUp = ""
-	case initProject:
-		tracing.SetUsageAttributes(fields.InitMethod.String("project"))
-
-		err = i.repoInitializer.InitializeMinimal(ctx, azdCtx)
-		if err != nil {
-			return nil, err
-		}
-
-		// Create env upfront only if the environment name is passed in.
-		if i.flags.EnvironmentName != "" {
-			_, err := i.initializeEnv(ctx, azdCtx, templates.Metadata{})
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		header = "Generated azure.yaml project file."
-		followUp = "Run " + output.WithHighLightFormat("azd add") + " to add new Azure components to your project."
 	default:
 		panic("unhandled init type")
 	}
@@ -358,17 +366,15 @@ const (
 	initUnknown = iota
 	initFromApp
 	initAppTemplate
-	initProject
 	initEnvironment
 )
 
 func promptInitType(console input.Console, ctx context.Context) (initType, error) {
 	selection, err := console.Select(ctx, input.ConsoleOptions{
 		Message: "How do you want to initialize your app?",
 		Options: []string{
-			"Use code in the current directory",
+			"Scan current directory", // This now covers minimal project creation too
 			"Select a template",
-			"Create a minimal project",
 		},
 	})
 	if err != nil {
@@ -380,8 +386,6 @@ func promptInitType(console input.Console, ctx context.Context) (initType, error
 		return initFromApp, nil
 	case 1:
 		return initAppTemplate, nil
-	case 2:
-		return initProject, nil
 	default:
 		panic("unhandled selection")
 	}

cli/azd/cmd/testdata/TestUsage-azd-init.snap

@@ -13,6 +13,7 @@ Flags
     -f, --filter strings      	: The tag(s) used to filter template results. Supports comma-separated values.
         --from-code           	: Initializes a new application from your existing code.
     -l, --location string     	: Azure location for the new environment
+    -m, --minimal             	: Initializes a minimal project.
     -s, --subscription string 	: Name or ID of an Azure subscription to use for the new environment
     -t, --template string     	: Initializes a new application from a template. You can use Full URI, <owner>/<repository>, or <repository> if it's part of the azure-samples organization.
         --up                  	: Provision and deploy to Azure after initializing the project from a template.

cli/azd/internal/repository/app_init.go

@@ -35,6 +35,7 @@ func (i *Initializer) InitFromApp(
 	ctx context.Context,
 	azdCtx *azdcontext.AzdContext,
 	initializeEnv func() (*environment.Environment, error),
+	initializeMinimal func() error,
 	envSpecified bool) error {
 	i.console.Message(ctx, "")
 	title := "Scanning app code in current directory"
@@ -235,6 +236,10 @@ func (i *Initializer) InitFromApp(
 	tracing.SetUsageAttributes(fields.AppInitLastStep.String("config"))
 	tracing.SetUsageAttributes(fields.AppInitLastStep.String("generate"))
 
+	if len(detect.Services) == 0 && len(detect.Databases) == 0 {
+		return initializeMinimal()
+	}
+
 	// Defer env initialization until 'azd up', except cases where user explicitly specifies the env name
 	if envSpecified {
 		_, err = initializeEnv()
@@ -258,8 +263,7 @@ func (i *Initializer) InitFromApp(
 		return fmt.Errorf("loading scaffold templates: %w", err)
 	}
 
-	// TODO: Merge next-steps.md and next-steps-alpha.md
-	err = scaffold.Execute(t, "next-steps-alpha.md", nil, filepath.Join(azdCtx.ProjectDirectory(), "next-steps.md"))
+	err = scaffold.Execute(t, "next-steps.md", nil, filepath.Join(azdCtx.ProjectDirectory(), "next-steps.md"))
 	if err != nil {
 		return err
 	}

cli/azd/internal/repository/detect_confirm.go

@@ -106,69 +106,54 @@ func (d *detectConfirm) captureUsage(
 // Confirm prompts the user to confirm the detected services and databases,
 // providing modifications to the detected services and databases.
 func (d *detectConfirm) Confirm(ctx context.Context) error {
+	const (
+		optionConfirmAndContinue = "Confirm and continue initializing my app"
+		optionRemoveService      = "Remove a detected service"
+		optionAddService         = "Add an undetected service"
+	)
+
 	for {
 		if err := d.render(ctx); err != nil {
 			return err
 		}
 
-		if len(d.Services) == 0 && !d.modified {
-			confirmAdd, err := d.console.Confirm(ctx, input.ConsoleOptions{
-				Message:      "Add an undetected service?",
-				DefaultValue: true,
-			})
-			if err != nil {
-				return err
-			}
-
-			if !confirmAdd {
-				return fmt.Errorf("cancelled")
-			}
-
-			if err := d.add(ctx); err != nil {
-				return err
-			}
-
-			tracing.IncrementUsageAttribute(fields.AppInitModifyAddCount.Int(1))
-			continue
+		options := []string{optionConfirmAndContinue}
+		if len(d.Services) > 0 || len(d.Databases) > 0 {
+			options = append(options, optionRemoveService)
 		}
+		options = append(options, optionAddService)
 
-		d.modified = false
-
-		continueOption, err := d.console.Select(ctx, input.ConsoleOptions{
+		selectedOptionIndex, err := d.console.Select(ctx, input.ConsoleOptions{
 			Message: "Select an option",
-			Options: []string{
-				"Confirm and continue initializing my app",
-				"Remove a detected service",
-				"Add an undetected service",
-			},
+			Options: options,
 		})
 		if err != nil {
 			return err
 		}
 
-		switch continueOption {
-		case 0:
+		selectedOption := options[selectedOptionIndex]
+
+		switch selectedOption {
+		case optionConfirmAndContinue:
 			d.captureUsage(
 				fields.AppInitConfirmedDatabases,
 				fields.AppInitConfirmedServices)
 			return nil
-		case 1:
+		case optionRemoveService:
 			if err := d.remove(ctx); err != nil {
 				if errors.Is(err, terminal.InterruptErr) {
 					continue
 				}
 				return err
 			}
-
 			tracing.IncrementUsageAttribute(fields.AppInitModifyRemoveCount.Int(1))
-		case 2:
+		case optionAddService:
 			if err := d.add(ctx); err != nil {
 				if errors.Is(err, terminal.InterruptErr) {
 					continue
 				}
 				return err
 			}
-
 			tracing.IncrementUsageAttribute(fields.AppInitModifyAddCount.Int(1))
 		}
 	}

cli/azd/internal/repository/detect_confirm_test.go

@@ -47,7 +47,7 @@ func Test_detectConfirm_confirm(t *testing.T) {
 			name:      "add from empty",
 			detection: []appdetect.Project{},
 			interactions: []string{
-				"y",
+				"Add an undetected service",
 				fmt.Sprintf("%s\t%s", appdetect.Java.Display(), "[Language]"),
 				"java-dir",
 				"Confirm and continue initializing my app",