feat: azd init -t auto-creates project directory like git clone

When using azd init -t <template>, automatically create a project
directory named after the template and initialize inside it, similar
to how git clone creates a directory.

Changes:
- Add optional [directory] positional argument to azd init
- Auto-derive folder name from template path (git clone conventions)
- Create directory, os.Chdir into it, run full init pipeline inside
- Pass "." to use current directory (preserves existing behavior)
- Show cd hint after init so users know how to enter the project
- Add DeriveDirectoryName() helper with path traversal protection
- Validate target directory: prompt if non-empty, error with --no-prompt

Fixes #7289
Related to #4032

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: spboyer

cli/azd/cmd/init.go

@@ -30,6 +30,7 @@ import (
 	"github.com/azure/azure-dev/cli/azd/pkg/extensions"
 	"github.com/azure/azure-dev/cli/azd/pkg/input"
 	"github.com/azure/azure-dev/cli/azd/pkg/lazy"
+	"github.com/azure/azure-dev/cli/azd/pkg/osutil"
 	"github.com/azure/azure-dev/cli/azd/pkg/output"
 	"github.com/azure/azure-dev/cli/azd/pkg/output/ux"
 	"github.com/azure/azure-dev/cli/azd/pkg/project"
@@ -53,8 +54,14 @@ func newInitFlags(cmd *cobra.Command, global *internal.GlobalCommandOptions) *in
 
 func newInitCmd() *cobra.Command {
 	return &cobra.Command{
-		Use:   "init",
+		Use:   "init [directory]",
 		Short: "Initialize a new application.",
+		Long: `Initialize a new application.
+
+When used with --template, a new directory is created (named after the template)
+and the project is initialized inside it — similar to git clone.
+Pass "." as the directory to initialize in the current directory instead.`,
+		Args: cobra.MaximumNArgs(1),
 	}
 }
 
@@ -134,6 +141,7 @@ type initAction struct {
 	cmdRun            exec.CommandRunner
 	gitCli            *git.Cli
 	flags             *initFlags
+	args              []string
 	repoInitializer   *repository.Initializer
 	templateManager   *templates.TemplateManager
 	featuresManager   *alpha.FeatureManager
@@ -151,6 +159,7 @@ func newInitAction(
 	console input.Console,
 	gitCli *git.Cli,
 	flags *initFlags,
+	args []string,
 	repoInitializer *repository.Initializer,
 	templateManager *templates.TemplateManager,
 	featuresManager *alpha.FeatureManager,
@@ -167,6 +176,7 @@ func newInitAction(
 		cmdRun:            cmdRun,
 		gitCli:            gitCli,
 		flags:             flags,
+		args:              args,
 		repoInitializer:   repoInitializer,
 		templateManager:   templateManager,
 		featuresManager:   featuresManager,
@@ -184,6 +194,40 @@ func (i *initAction) Run(ctx context.Context) (*actions.ActionResult, error) {
 		return nil, fmt.Errorf("getting cwd: %w", err)
 	}
 
+	// When a template is specified, auto-create a project directory (like git clone).
+	// The user can pass a positional [directory] argument to override the folder name,
+	// or pass "." to use the current directory (preserving existing behavior).
+	createdProjectDir := ""
+	originalWd := wd
+	isTemplateInit := i.flags.templatePath != "" || len(i.flags.templateTags) > 0
+
+	if isTemplateInit {
+		targetDir, err := i.resolveTargetDirectory(wd)
+		if err != nil {
+			return nil, err
+		}
+
+		if targetDir != wd {
+			// Check if target already exists and is non-empty
+			if err := i.validateTargetDirectory(ctx, targetDir); err != nil {
+				return nil, err
+			}
+
+			if err := os.MkdirAll(targetDir, osutil.PermissionDirectory); err != nil {
+				return nil, fmt.Errorf("creating project directory '%s': %w",
+					filepath.Base(targetDir), err)
+			}
+
+			if err := os.Chdir(targetDir); err != nil {
+				return nil, fmt.Errorf("changing to project directory '%s': %w",
+					filepath.Base(targetDir), err)
+			}
+
+			wd = targetDir
+			createdProjectDir = targetDir
+		}
+	}
+
 	azdCtx := azdcontext.NewAzdContextWithDirectory(wd)
 	i.lazyAzdCtx.SetValue(azdCtx)
 
@@ -281,6 +325,16 @@ func (i *initAction) Run(ctx context.Context) (*actions.ActionResult, error) {
 		output.WithLinkFormat("%s", wd),
 		output.WithLinkFormat("%s", "https://aka.ms/azd-third-party-code-notice"))
 
+	if createdProjectDir != "" {
+		// Compute a user-friendly cd path relative to where they started
+		cdPath, relErr := filepath.Rel(originalWd, createdProjectDir)
+		if relErr != nil {
+			cdPath = createdProjectDir // Fall back to absolute path
+		}
+		followUp += fmt.Sprintf("\n\nChange to the project directory:\n  %s",
+			output.WithHighLightFormat("cd %s", cdPath))
+	}
+
 	if i.featuresManager.IsEnabled(agentcopilot.FeatureCopilot) {
 		followUp += fmt.Sprintf("\n\n%s Run %s to deploy project to the cloud.",
 			output.WithHintFormat("(→) NEXT STEPS:"),
@@ -910,3 +964,70 @@ type initModeRequiredErrorOptions struct {
 	Description string `json:"description"`
 	Command     string `json:"command"`
 }
+
+// resolveTargetDirectory determines the target directory for template initialization.
+// It returns the current working directory when "." is passed or no template is specified,
+// otherwise it derives or uses the explicit directory name.
+func (i *initAction) resolveTargetDirectory(wd string) (string, error) {
+	if len(i.args) > 0 {
+		dirArg := i.args[0]
+		if dirArg == "." {
+			return wd, nil
+		}
+
+		if filepath.IsAbs(dirArg) {
+			return dirArg, nil
+		}
+
+		return filepath.Join(wd, dirArg), nil
+	}
+
+	// No positional arg: auto-derive from template path
+	if i.flags.templatePath != "" {
+		dirName := templates.DeriveDirectoryName(i.flags.templatePath)
+		return filepath.Join(wd, dirName), nil
+	}
+
+	// Template selected via --filter tags (interactive selection) — use CWD
+	return wd, nil
+}
+
+// validateTargetDirectory checks that the target directory is safe to use.
+// If it already exists and is non-empty, it prompts the user for confirmation
+// or returns an error in non-interactive mode.
+func (i *initAction) validateTargetDirectory(ctx context.Context, targetDir string) error {
+	entries, err := os.ReadDir(targetDir)
+	if errors.Is(err, os.ErrNotExist) {
+		return nil // Directory doesn't exist yet — will be created
+	}
+	if err != nil {
+		return fmt.Errorf("reading directory '%s': %w", filepath.Base(targetDir), err)
+	}
+
+	if len(entries) == 0 {
+		return nil // Empty directory is fine
+	}
+
+	dirName := filepath.Base(targetDir)
+
+	if i.console.IsNoPromptMode() {
+		return fmt.Errorf(
+			"directory '%s' already exists and is not empty; "+
+				"use '.' to initialize in the current directory instead", dirName)
+	}
+
+	proceed, err := i.console.Confirm(ctx, input.ConsoleOptions{
+		Message: fmt.Sprintf(
+			"Directory '%s' already exists and is not empty. Initialize here anyway?", dirName),
+		DefaultValue: false,
+	})
+	if err != nil {
+		return fmt.Errorf("prompting for directory confirmation: %w", err)
+	}
+
+	if !proceed {
+		return errors.New("initialization cancelled")
+	}
+
+	return nil
+}

cli/azd/cmd/init_test.go

@@ -25,7 +25,9 @@ import (
 
 // setupInitAction creates an initAction wired with mocks that pass git-install checks.
 // The working directory is changed to a temp dir so that .env loading and azdcontext work.
-func setupInitAction(t *testing.T, mockContext *mocks.MockContext, flags *initFlags) *initAction {
+func setupInitAction(
+	t *testing.T, mockContext *mocks.MockContext, flags *initFlags, args ...string,
+) *initAction {
 	t.Helper()
 
 	// Work in a temp directory so os.Getwd / godotenv.Overload operate in isolation.
@@ -50,6 +52,7 @@ func setupInitAction(t *testing.T, mockContext *mocks.MockContext, flags *initFl
 		cmdRun:          mockContext.CommandRunner,
 		gitCli:          gitCli,
 		flags:           flags,
+		args:            args,
 		featuresManager: alpha.NewFeaturesManagerWithConfig(config.NewEmptyConfig()),
 	}
 }
@@ -231,3 +234,195 @@ func TestInitFailFastMissingEnvNonInteractive(t *testing.T) {
 		}
 	})
 }
+
+func TestInitResolveTargetDirectory(t *testing.T) {
+	t.Run("DotArgUsesCwd", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		flags := &initFlags{
+			templatePath: "owner/repo",
+			global:       &internal.GlobalCommandOptions{},
+		}
+		action := setupInitAction(t, mockContext, flags, ".")
+
+		wd, err := os.Getwd()
+		require.NoError(t, err)
+
+		result, err := action.resolveTargetDirectory(wd)
+		require.NoError(t, err)
+		require.Equal(t, wd, result)
+	})
+
+	t.Run("ExplicitDirectoryUsesArg", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		flags := &initFlags{
+			templatePath: "owner/repo",
+			global:       &internal.GlobalCommandOptions{},
+		}
+		action := setupInitAction(t, mockContext, flags, "my-project")
+
+		wd, err := os.Getwd()
+		require.NoError(t, err)
+
+		result, err := action.resolveTargetDirectory(wd)
+		require.NoError(t, err)
+		require.Equal(t, filepath.Join(wd, "my-project"), result)
+	})
+
+	t.Run("NoArgDerivesFromTemplatePath", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		flags := &initFlags{
+			templatePath: "Azure-Samples/todo-nodejs-mongo",
+			global:       &internal.GlobalCommandOptions{},
+		}
+		action := setupInitAction(t, mockContext, flags)
+
+		wd, err := os.Getwd()
+		require.NoError(t, err)
+
+		result, err := action.resolveTargetDirectory(wd)
+		require.NoError(t, err)
+		require.Equal(t, filepath.Join(wd, "todo-nodejs-mongo"), result)
+	})
+
+	t.Run("NoArgWithFilterTagsUsesCwd", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		flags := &initFlags{
+			templateTags: []string{"python"},
+			global:       &internal.GlobalCommandOptions{},
+		}
+		action := setupInitAction(t, mockContext, flags)
+
+		wd, err := os.Getwd()
+		require.NoError(t, err)
+
+		result, err := action.resolveTargetDirectory(wd)
+		require.NoError(t, err)
+		require.Equal(t, wd, result)
+	})
+
+	t.Run("TemplateWithDotGitSuffix", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		flags := &initFlags{
+			templatePath: "https://github.com/Azure-Samples/todo-nodejs-mongo.git",
+			global:       &internal.GlobalCommandOptions{},
+		}
+		action := setupInitAction(t, mockContext, flags)
+
+		wd, err := os.Getwd()
+		require.NoError(t, err)
+
+		result, err := action.resolveTargetDirectory(wd)
+		require.NoError(t, err)
+		require.Equal(t, filepath.Join(wd, "todo-nodejs-mongo"), result)
+	})
+}
+
+func TestInitValidateTargetDirectory(t *testing.T) {
+	t.Run("NonExistentDirectoryIsValid", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		flags := &initFlags{
+			templatePath: "owner/repo",
+			global:       &internal.GlobalCommandOptions{},
+		}
+		action := setupInitAction(t, mockContext, flags)
+
+		err := action.validateTargetDirectory(
+			*mockContext.Context, filepath.Join(t.TempDir(), "nonexistent"))
+		require.NoError(t, err)
+	})
+
+	t.Run("EmptyDirectoryIsValid", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		flags := &initFlags{
+			templatePath: "owner/repo",
+			global:       &internal.GlobalCommandOptions{},
+		}
+		action := setupInitAction(t, mockContext, flags)
+
+		emptyDir := t.TempDir()
+		err := action.validateTargetDirectory(*mockContext.Context, emptyDir)
+		require.NoError(t, err)
+	})
+
+	t.Run("NonEmptyDirectoryErrorsInNoPromptMode", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		mockContext.Console.SetNoPromptMode(true)
+		flags := &initFlags{
+			templatePath: "owner/repo",
+			global:       &internal.GlobalCommandOptions{NoPrompt: true},
+		}
+		action := setupInitAction(t, mockContext, flags)
+
+		nonEmptyDir := t.TempDir()
+		require.NoError(t, os.WriteFile(
+			filepath.Join(nonEmptyDir, "existing.txt"), []byte("content"), 0600))
+
+		err := action.validateTargetDirectory(*mockContext.Context, nonEmptyDir)
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "already exists and is not empty")
+	})
+}
+
+func TestInitCreatesProjectDirectory(t *testing.T) {
+	t.Run("TemplateInitCreatesDirectory", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		mockContext.Console.SetNoPromptMode(true)
+		flags := &initFlags{
+			templatePath: "Azure-Samples/todo-nodejs-mongo",
+			global:       &internal.GlobalCommandOptions{NoPrompt: true},
+		}
+		flags.EnvironmentName = "testenv"
+		action := setupInitAction(t, mockContext, flags)
+
+		wd, err := os.Getwd()
+		require.NoError(t, err)
+
+		expectedDir := filepath.Join(wd, "todo-nodejs-mongo")
+		require.NoDirExists(t, expectedDir)
+
+		// Run will panic or error later due to missing template mocks,
+		// but the directory should be created before that point.
+		_ = runActionSafe(*mockContext.Context, action)
+		require.DirExists(t, expectedDir)
+	})
+
+	t.Run("DotArgDoesNotCreateDirectory", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		mockContext.Console.SetNoPromptMode(true)
+		flags := &initFlags{
+			templatePath: "Azure-Samples/todo-nodejs-mongo",
+			global:       &internal.GlobalCommandOptions{NoPrompt: true},
+		}
+		flags.EnvironmentName = "testenv"
+		action := setupInitAction(t, mockContext, flags, ".")
+
+		wd, err := os.Getwd()
+		require.NoError(t, err)
+
+		// Should NOT create a todo-nodejs-mongo subdirectory
+		_ = runActionSafe(*mockContext.Context, action)
+
+		derivedDir := filepath.Join(wd, "todo-nodejs-mongo")
+		require.NoDirExists(t, derivedDir)
+	})
+
+	t.Run("ExplicitDirArgCreatesNamedDirectory", func(t *testing.T) {
+		mockContext := mocks.NewMockContext(context.Background())
+		mockContext.Console.SetNoPromptMode(true)
+		flags := &initFlags{
+			templatePath: "Azure-Samples/todo-nodejs-mongo",
+			global:       &internal.GlobalCommandOptions{NoPrompt: true},
+		}
+		flags.EnvironmentName = "testenv"
+		action := setupInitAction(t, mockContext, flags, "my-custom-project")
+
+		wd, err := os.Getwd()
+		require.NoError(t, err)
+
+		expectedDir := filepath.Join(wd, "my-custom-project")
+		require.NoDirExists(t, expectedDir)
+
+		_ = runActionSafe(*mockContext.Context, action)
+		require.DirExists(t, expectedDir)
+	})
+}