Run package manifest config bootstrap flow by default in gh aw add (#46041)

Author: Copilot

cmd/gh-aw/main.go

@@ -697,9 +697,6 @@ Use "` + string(constants.CLIExtensionPrefix) + ` help all" to show help for all
 	// Create and setup add-wizard command
 	addWizardCmd := cli.NewAddWizardCommand(validateEngine)
 
-	// Create and setup bootstrap command
-	bootstrapCmd := cli.NewBootstrapCommand(validateEngine)
-
 	// Create and setup update command
 	updateCmd := cli.NewUpdateCommand(validateEngine)
 
@@ -842,7 +839,6 @@ Use "` + string(constants.CLIExtensionPrefix) + ` help all" to show help for all
 	newCmd.GroupID = "setup"
 	addCmd.GroupID = "setup"
 	addWizardCmd.GroupID = "setup"
-	bootstrapCmd.GroupID = "setup"
 	removeCmd.GroupID = "setup"
 	updateCmd.GroupID = "setup"
 	deployCmd.GroupID = "setup"
@@ -889,7 +885,6 @@ Use "` + string(constants.CLIExtensionPrefix) + ` help all" to show help for all
 	// Add all commands to root
 	rootCmd.AddCommand(addCmd)
 	rootCmd.AddCommand(addWizardCmd)
-	rootCmd.AddCommand(bootstrapCmd)
 	rootCmd.AddCommand(updateCmd)
 	rootCmd.AddCommand(deployCmd)
 	rootCmd.AddCommand(upgradeCmd)

pkg/cli/add_command.go

@@ -156,15 +156,31 @@ func runAddCommand(cmd *cobra.Command, args []string, validateEngine func(string
 	if err != nil {
 		return err
 	}
-	if _, err := AddResolvedWorkflows(cmd.Context(), args, resolved, opts); err != nil {
+	if err := rejectBootstrapProfileForRegularAdd(args, resolved.BootstrapProfile); err != nil {
+		return err
+	}
+	if err := ensureAddRepositoryInitialized(engineOverride, verbose); err != nil {
 		return err
 	}
-	if resolved.BootstrapProfile != nil {
-		printBootstrapConfigTODO(cmd.ErrOrStderr(), resolved.BootstrapProfile)
+	if _, err := AddResolvedWorkflows(cmd.Context(), args, resolved, opts); err != nil {
+		return err
 	}
 	return nil
 }
 
+func rejectBootstrapProfileForRegularAdd(sources []string, profile *resolvedBootstrapProfile) error {
+	if profile == nil || profile.Profile == nil || len(profile.Profile.Config) == 0 {
+		return nil
+	}
+
+	requestedSources := strings.Join(sources, " ")
+	if requestedSources == "" {
+		requestedSources = profile.PackageID
+	}
+
+	return fmt.Errorf("package %s declares aw.yml config and cannot be installed with 'gh aw add'. Use 'gh aw add-wizard %s' so the config steps can run interactively", profile.PackageID, requestedSources)
+}
+
 func registerAddCommandFlags(cmd *cobra.Command) {
 	// Add name flag to add command
 	cmd.Flags().StringP("name", "n", "", "Specify name for the added workflow (without .md extension)")
@@ -390,7 +406,11 @@ func addWorkflowWithTracking(ctx context.Context, resolved *ResolvedWorkflow, tr
 	if resolved.IsPackageAgentFile {
 		return addAgentFileWithTracking(resolved, tracker, opts, gitRoot)
 	}
-	skip, err := validateWorkflowDestination(githubWorkflowsDir, workflowName, opts)
+	sourceRepo := ""
+	if sourceInfo != nil && !sourceInfo.IsLocal {
+		sourceRepo = workflowSpec.RepoSlug
+	}
+	skip, err := validateWorkflowDestination(githubWorkflowsDir, workflowName, sourceRepo, opts)
 	if err != nil {
 		return err
 	}
@@ -430,11 +450,18 @@ func reportAddWorkflowStart(workflowSpec *WorkflowSpec, sourceContent []byte, op
 	fmt.Fprintln(os.Stderr, console.FormatSuccessMessage(fmt.Sprintf("Using pre-fetched workflow content (%d bytes)", len(sourceContent))))
 }
 
-func validateWorkflowDestination(githubWorkflowsDir, workflowName string, opts AddOptions) (bool, error) {
+func validateWorkflowDestination(githubWorkflowsDir, workflowName, sourceRepo string, opts AddOptions) (bool, error) {
 	existingFile := filepath.Join(githubWorkflowsDir, workflowName+".md")
 	if !fileutil.FileExists(existingFile) || opts.Force {
 		return false, nil
 	}
+	if sourceRepo != "" {
+		existingSourceRepo := readSourceRepoFromFile(existingFile)
+		if existingSourceRepo == sourceRepo {
+			fmt.Fprintln(os.Stderr, console.FormatInfoMessage("Workflow from same source already exists, skipping: "+existingFile))
+			return true, nil
+		}
+	}
 	if opts.FromWildcard {
 		fmt.Fprintln(os.Stderr, console.FormatWarningMessage(fmt.Sprintf("Workflow '%s' already exists in .github/workflows/. Skipping.", workflowName)))
 		return true, nil

pkg/cli/add_command_test.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/github/gh-aw/pkg/gitutil"
 	"github.com/github/gh-aw/pkg/testutil"
 	"github.com/github/gh-aw/pkg/workflow"
 	"github.com/spf13/cobra"
@@ -367,6 +368,198 @@ func TestAddCommandArgs(t *testing.T) {
 	require.NoError(t, err, "Should not error with multiple arguments")
 }
 
+func TestRejectBootstrapProfileForRegularAdd(t *testing.T) {
+	profileWithConfig := &resolvedBootstrapProfile{
+		PackageID: "githubnext/central-agentic-ops",
+		Profile: &repositoryPackageBootstrap{
+			Config: []repositoryPackageBootstrapAction{
+				{Type: "repo-variable", Name: "EXAMPLE", Prompt: "Enter value"},
+			},
+		},
+	}
+
+	t.Run("rejects regular add for packages with manifest config", func(t *testing.T) {
+		err := rejectBootstrapProfileForRegularAdd([]string{"githubnext/central-agentic-ops"}, profileWithConfig)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "package githubnext/central-agentic-ops declares aw.yml config")
+		assert.Contains(t, err.Error(), "gh aw add-wizard githubnext/central-agentic-ops")
+	})
+
+	t.Run("uses requested sources in the add-wizard guidance", func(t *testing.T) {
+		err := rejectBootstrapProfileForRegularAdd([]string{"githubnext/central-agentic-ops", "./local-workflow.md"}, profileWithConfig)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "gh aw add-wizard githubnext/central-agentic-ops ./local-workflow.md")
+	})
+
+	t.Run("allows packages without manifest config", func(t *testing.T) {
+		err := rejectBootstrapProfileForRegularAdd([]string{"owner/pkg"}, nil)
+		require.NoError(t, err)
+
+		err = rejectBootstrapProfileForRegularAdd([]string{"owner/pkg"}, &resolvedBootstrapProfile{
+			PackageID: "owner/pkg",
+			Profile:   &repositoryPackageBootstrap{Config: nil},
+		})
+		require.NoError(t, err)
+	})
+}
+
+func TestEnsureAddRepositoryInitialized(t *testing.T) {
+	originalFindGitRoot := addFindGitRoot
+	originalInitRepository := addInitRepository
+	originalMissingInitMarkers := addMissingInitMarkers
+	t.Cleanup(func() {
+		addFindGitRoot = originalFindGitRoot
+		addInitRepository = originalInitRepository
+		addMissingInitMarkers = originalMissingInitMarkers
+	})
+
+	t.Run("skips initialization outside a git checkout", func(t *testing.T) {
+		addFindGitRoot = func() (string, error) { return "", gitutil.ErrNotGitRepository }
+		addMissingInitMarkers = func(string, string) ([]string, error) {
+			t.Fatal("missing init markers check should be skipped outside a git checkout")
+			return nil, nil
+		}
+		addInitRepository = func(InitOptions) error {
+			t.Fatal("InitRepository should not run outside a git checkout")
+			return nil
+		}
+
+		err := ensureAddRepositoryInitialized("", false)
+		require.NoError(t, err)
+	})
+
+	t.Run("runs init when required markers are missing", func(t *testing.T) {
+		repoDir := t.TempDir()
+		addFindGitRoot = func() (string, error) { return repoDir, nil }
+		addMissingInitMarkers = func(baseDir string, engineOverride string) ([]string, error) {
+			assert.Equal(t, ".", baseDir)
+			assert.Equal(t, "claude", engineOverride)
+			return []string{".gitattributes"}, nil
+		}
+
+		called := false
+		addInitRepository = func(opts InitOptions) error {
+			called = true
+			assert.True(t, opts.Verbose)
+			assert.Equal(t, "claude", opts.Engine)
+			assert.True(t, opts.Skill)
+			assert.True(t, opts.Agent)
+			assert.True(t, opts.MCP)
+			assert.False(t, opts.CodespaceEnabled)
+			assert.False(t, opts.Completions)
+			assert.False(t, opts.CreatePR)
+			return nil
+		}
+
+		err := ensureAddRepositoryInitialized("claude", true)
+		require.NoError(t, err)
+		assert.True(t, called)
+	})
+
+	t.Run("does nothing when markers are already present", func(t *testing.T) {
+		repoDir := t.TempDir()
+		addFindGitRoot = func() (string, error) { return repoDir, nil }
+		addMissingInitMarkers = func(string, string) ([]string, error) { return nil, nil }
+		addInitRepository = func(InitOptions) error {
+			t.Fatal("InitRepository should not run when markers are already present")
+			return nil
+		}
+
+		err := ensureAddRepositoryInitialized("", false)
+		require.NoError(t, err)
+	})
+}
+
+func TestAddResolvedWorkflows_IgnoresBootstrapRequireOwnerTypeDuringInstall(t *testing.T) {
+	originalCheckOwnerType := bootstrapCheckOwnerType
+	t.Cleanup(func() {
+		bootstrapCheckOwnerType = originalCheckOwnerType
+	})
+
+	bootstrapCheckOwnerType = func(context.Context, string) (string, error) { return "User", nil }
+
+	resolved := &ResolvedWorkflows{
+		Workflows: nil,
+		BootstrapProfile: &resolvedBootstrapProfile{
+			PackageID: "githubnext/central-agentic-ops",
+			Profile: &repositoryPackageBootstrap{
+				Config: []repositoryPackageBootstrapAction{{Type: "require-owner-type", Value: "org"}},
+			},
+		},
+	}
+
+	_, err := AddResolvedWorkflows(context.Background(), []string{"githubnext/central-agentic-ops"}, resolved, AddOptions{NoGitattributes: true})
+	require.NoError(t, err)
+}
+
+func TestCompileDispatchWorkflowDependencies_FallsBackToRawFrontmatter(t *testing.T) {
+	tmpDir := testutil.TempDir(t, "dispatch-workflow-fallback-*")
+	workflowsDir := setupMinimalGitRepo(t, tmpDir)
+
+	mainPath := filepath.Join(workflowsDir, "dispatcher.md")
+	workerPath := filepath.Join(workflowsDir, "worker.md")
+
+	require.NoError(t, os.WriteFile(mainPath, []byte(`---
+name: Dispatcher
+on:
+  workflow_dispatch:
+safe-outputs:
+  dispatch-workflow:
+    workflows: [worker]
+imports:
+  - uses: shared/missing.md
+---
+
+# Dispatcher
+`), 0o644))
+	require.NoError(t, os.WriteFile(workerPath, []byte(`---
+name: Worker
+on:
+  workflow_dispatch:
+---
+
+# Worker
+`), 0o644))
+
+	compileDispatchWorkflowDependencies(context.Background(), mainPath, false, true, "", nil)
+
+	lockPath := filepath.Join(workflowsDir, "worker.lock.yml")
+	_, err := os.Stat(lockPath)
+	require.NoError(t, err, "dispatch dependency should still be compiled when merged parse fails")
+	lockContent, err := os.ReadFile(lockPath)
+	require.NoError(t, err)
+	assert.Contains(t, string(lockContent), "name: \"Worker\"", "compiled dispatch dependency should preserve its workflow name")
+}
+
+func TestValidateWorkflowDestination_SkipsExistingWorkflowFromSameSource(t *testing.T) {
+	workflowsDir := t.TempDir()
+	existingPath := filepath.Join(workflowsDir, "dependabot.md")
+	require.NoError(t, os.WriteFile(existingPath, []byte(`---
+source: githubnext/central-agentic-ops/.github/workflows/dependabot.md@main
+---
+# Dependabot
+`), 0o644))
+
+	skip, err := validateWorkflowDestination(workflowsDir, "dependabot", "githubnext/central-agentic-ops", AddOptions{})
+	require.NoError(t, err)
+	assert.True(t, skip)
+}
+
+func TestValidateWorkflowDestination_ErrorsForExistingWorkflowFromDifferentSource(t *testing.T) {
+	workflowsDir := t.TempDir()
+	existingPath := filepath.Join(workflowsDir, "dependabot.md")
+	require.NoError(t, os.WriteFile(existingPath, []byte(`---
+source: octo/other/.github/workflows/dependabot.md@main
+---
+# Dependabot
+`), 0o644))
+
+	skip, err := validateWorkflowDestination(workflowsDir, "dependabot", "githubnext/central-agentic-ops", AddOptions{})
+	require.Error(t, err)
+	assert.False(t, skip)
+	assert.Contains(t, err.Error(), "workflow 'dependabot' already exists")
+}
+
 // TestAddMultipleWorkflowsNameFlag verifies that --name is not allowed when multiple workflows are specified.
 func TestAddMultipleWorkflowsNameFlag(t *testing.T) {
 	cmd := NewAddCommand(validateEngineStub)

pkg/cli/add_init.go

@@ -0,0 +1,62 @@
+package cli
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/github/gh-aw/pkg/gitutil"
+)
+
+var addFindGitRoot = gitutil.FindGitRoot
+var addInitRepository = InitRepository
+var addMissingInitMarkers = missingBootstrapInitMarkers
+
+func ensureAddRepositoryInitialized(engineOverride string, verbose bool) error {
+	_, err := ensureAddRepositoryInitializedWithDetails(engineOverride, verbose)
+	return err
+}
+
+func ensureAddRepositoryInitializedWithDetails(engineOverride string, verbose bool) ([]string, error) {
+	gitRoot, err := addFindGitRoot()
+	if err != nil {
+		if errors.Is(err, gitutil.ErrNotGitRepository) {
+			addLog.Print("Skipping automatic repository initialization outside a git checkout")
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to determine repository root for automatic initialization: %w", err)
+	}
+
+	var initializedFiles []string
+	err = withWorkingDir(gitRoot, func() error {
+		missingMarkers, err := addMissingInitMarkers(".", engineOverride)
+		if err != nil {
+			return fmt.Errorf("failed to inspect repository initialization state: %w", err)
+		}
+		if len(missingMarkers) == 0 {
+			return nil
+		}
+		initializedFiles = append(initializedFiles, missingMarkers...)
+
+		addLog.Printf("Repository missing init markers; running init: %v", missingMarkers)
+		if err := addInitRepository(InitOptions{
+			Verbose:          verbose,
+			Engine:           engineOverride,
+			Skill:            true,
+			Agent:            true,
+			MCP:              true,
+			CodespaceRepos:   []string{},
+			CodespaceEnabled: false,
+			Completions:      false,
+			CreatePR:         false,
+		}); err != nil {
+			return fmt.Errorf("failed to initialize repository for agentic workflows: %w", err)
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return initializedFiles, nil
+}

pkg/cli/add_interactive_orchestrator.go

@@ -135,8 +135,13 @@ func RunAddInteractive(ctx context.Context, config *AddInteractiveConfig) error
 		return err
 	}
 
+	initFiles, err := ensureAddRepositoryInitializedWithDetails(config.EngineOverride, config.Verbose)
+	if err != nil {
+		return err
+	}
+
 	// Step 7: Determine files to add
-	filesToAdd, initFiles, err := config.determineFilesToAdd()
+	filesToAdd, _, err := config.determineFilesToAdd()
 	if err != nil {
 		return err
 	}
@@ -311,6 +316,13 @@ func (c *AddInteractiveConfig) confirmChanges(workflowFiles, initFiles []string,
 	addInteractiveLog.Print("Confirming changes with user")
 
 	fmt.Fprintln(os.Stderr, "")
+	if len(initFiles) > 0 {
+		fmt.Fprintln(os.Stderr, "The repository will also be initialized with:")
+		for _, f := range initFiles {
+			fmt.Fprintf(os.Stderr, "  • %s\n", f)
+		}
+		fmt.Fprintln(os.Stderr, "")
+	}
 
 	confirmed := true // Default to yes
 	form := console.NewConfirmForm(