Enhance deploy command to support deploying all stacks in context

- Add optional stack name parameter to deploy command
- Change argument validation from ExactArgs(2) to RangeArgs(1, 2)
- Implement ListStacks method in ConfigProvider interface and file provider
- Deploy all stacks with dependency ordering when no specific stack provided
- Add comprehensive test coverage for new functionality
- Update documentation with examples for both deployment patterns
- Maintain full backward compatibility with existing usage

Usage:
  stackaroo deploy <context>            # Deploy all stacks in context
  stackaroo deploy <context> <stack>    # Deploy specific stack (unchanged)

Author: orien

README.md

@@ -55,3 +55,54 @@ go install github.com/orien/stackaroo@latest
 ```
 
 Or download a binary from the [releases page](https://github.com/orien/stackaroo/releases).
+
+## Quick Start
+
+### Configuration
+
+Create a `stackaroo.yaml` file defining your stacks and contexts:
+
+```yaml
+project: my-infrastructure
+region: us-east-1
+
+contexts:
+  development:
+    account: "123456789012"
+    region: ap-southeast-4
+    tags:
+      Environment: development
+  production:
+    account: "987654321098"
+    region: us-east-1
+    tags:
+      Environment: production
+
+stacks:
+  - name: vpc
+    template: templates/vpc.yaml
+  - name: app
+    template: templates/app.yaml
+    depends_on:
+      - vpc
+```
+
+### Deployment
+
+Deploy stacks using either pattern:
+
+```bash
+# Deploy all stacks in a context (with dependency ordering)
+stackaroo deploy development
+
+# Deploy a specific stack (with its dependencies)
+stackaroo deploy development vpc
+
+# Preview changes before deployment
+stackaroo diff development app
+```
+
+### Key Commands
+
+- `deploy <context> [stack]` - Deploy all stacks or a specific stack
+- `diff <context> <stack>` - Preview changes before deployment

cmd/deploy.go

@@ -22,7 +22,7 @@ var (
 
 // deployCmd represents the deploy command
 var deployCmd = &cobra.Command{
-	Use:   "deploy <context> <stack-name>",
+	Use:   "deploy <context> [stack-name]",
 	Short: "Deploy CloudFormation stacks",
 	Long: `Deploy CloudFormation stacks with integrated change preview.
 
@@ -37,16 +37,23 @@ ChangeSets to provide accurate previews including:
 
 For new stacks, the command proceeds directly with stack creation.
 
+If no stack name is provided, all stacks in the context will be deployed in 
+dependency order.
+
 Examples:
-  stackaroo deploy dev vpc
-  stackaroo deploy prod app
+  stackaroo deploy dev            # Deploy all stacks in dev context
+  stackaroo deploy dev vpc        # Deploy only the vpc stack in dev context
+  stackaroo deploy prod app       # Deploy only the app stack in prod context
 
 The preview shows the same detailed diff information as 'stackaroo diff' but 
 automatically proceeds with deployment after displaying the changes.`,
-	Args: cobra.ExactArgs(2),
+	Args: cobra.RangeArgs(1, 2),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		contextName := args[0]
-		stackName := args[1]
+		var stackName string
+		if len(args) > 1 {
+			stackName = args[1]
+		}
 		ctx := context.Background()
 
 		return deployWithConfig(ctx, stackName, contextName)
@@ -82,8 +89,26 @@ func deployWithConfig(ctx context.Context, stackName, contextName string) error
 	provider := file.NewDefaultProvider()
 	resolver := resolve.NewStackResolver(provider)
 
-	// Resolve stack and all its dependencies
-	resolved, err := resolver.Resolve(ctx, contextName, []string{stackName})
+	// Determine which stacks to deploy
+	var stackNames []string
+	if stackName != "" {
+		// Deploy single stack
+		stackNames = []string{stackName}
+	} else {
+		// Deploy all stacks in context
+		var err error
+		stackNames, err = provider.ListStacks(contextName)
+		if err != nil {
+			return fmt.Errorf("failed to get stacks for context %s: %w", contextName, err)
+		}
+		if len(stackNames) == 0 {
+			fmt.Printf("No stacks found in context %s\n", contextName)
+			return nil
+		}
+	}
+
+	// Resolve stack(s) and all their dependencies
+	resolved, err := resolver.Resolve(ctx, contextName, stackNames)
 	if err != nil {
 		return fmt.Errorf("failed to resolve stack dependencies: %w", err)
 	}

cmd/deploy_test.go

@@ -41,7 +41,7 @@ func TestDeployCommand_Exists(t *testing.T) {
 	deployCmd := findCommand(rootCmd, "deploy")
 
 	assert.NotNil(t, deployCmd, "deploy command should be registered")
-	assert.Equal(t, "deploy <context> <stack-name>", deployCmd.Use)
+	assert.Equal(t, "deploy <context> [stack-name]", deployCmd.Use)
 }
 
 func TestDeployCommand_AcceptsStackName(t *testing.T) {
@@ -54,23 +54,23 @@ func TestDeployCommand_AcceptsStackName(t *testing.T) {
 }
 
 func TestDeployCommand_AcceptsTwoArgs(t *testing.T) {
-	// Test that deploy command accepts exactly two arguments (context and stack name)
+	// Test that deploy command accepts one or two arguments (context and optional stack name)
 	deployCmd := findCommand(rootCmd, "deploy")
 	assert.NotNil(t, deployCmd)
 
-	// Test that Args validation requires exactly 2 arguments
+	// Test that Args validation accepts 1-2 arguments
 	err := deployCmd.Args(deployCmd, []string{"dev", "vpc"})
 	assert.NoError(t, err, "Two arguments should be valid")
 
 	err = deployCmd.Args(deployCmd, []string{"dev"})
-	assert.Error(t, err, "One argument should be invalid")
+	assert.NoError(t, err, "One argument should be valid")
 
 	err = deployCmd.Args(deployCmd, []string{})
 	assert.Error(t, err, "No arguments should be invalid")
 }
 
-func TestDeployCommand_RequiresTwoArgs(t *testing.T) {
-	// Test that deploy command requires both context and stack name arguments
+func TestDeployCommand_RequiresAtLeastOneArg(t *testing.T) {
+	// Test that deploy command requires at least a context argument
 
 	// Mock deployer that shouldn't be called
 	mockDeployer := &MockDeployer{}
@@ -79,12 +79,133 @@ func TestDeployCommand_RequiresTwoArgs(t *testing.T) {
 	SetDeployer(mockDeployer)
 	defer SetDeployer(oldDeployer)
 
-	// Execute with only one argument - should fail
-	rootCmd.SetArgs([]string{"deploy", "test-stack"})
+	// Execute with no arguments - should fail
+	rootCmd.SetArgs([]string{"deploy"})
 
 	err := rootCmd.Execute()
-	assert.Error(t, err, "deploy command should require both context and stack name arguments")
-	assert.Contains(t, err.Error(), "accepts 2 arg(s), received 1")
+	assert.Error(t, err, "deploy command should require at least a context argument")
+	assert.Contains(t, err.Error(), "accepts between 1 and 2 arg(s), received 0")
+
+	// Verify no deployer calls were made
+	mockDeployer.AssertExpectations(t)
+}
+
+func TestDeployCommand_DeployAllStacksInContext(t *testing.T) {
+	// Test that deploy command with single argument deploys all stacks in context
+
+	// Create a temporary config file with multiple stacks
+	configContent := `
+project: test-project
+
+contexts:
+  test-context:
+    region: us-east-1
+
+stacks:
+  - name: vpc
+    template: templates/vpc.yaml
+  - name: app 
+    template: templates/app.yaml
+`
+	tmpDir := t.TempDir()
+	configFile := tmpDir + "/stackaroo.yaml"
+	err := os.WriteFile(configFile, []byte(configContent), 0644)
+	require.NoError(t, err)
+
+	// Create template files
+	err = os.MkdirAll(tmpDir+"/templates", 0755)
+	require.NoError(t, err)
+
+	vpcTemplate := `AWSTemplateFormatVersion: '2010-09-09'
+Resources:
+  TestVPC:
+    Type: AWS::EC2::VPC
+    Properties:
+      CidrBlock: 10.0.0.0/16`
+
+	appTemplate := `AWSTemplateFormatVersion: '2010-09-09'
+Resources:
+  TestApp:
+    Type: AWS::EC2::Instance
+    Properties:
+      ImageId: ami-12345678
+      InstanceType: t2.micro`
+
+	err = os.WriteFile(tmpDir+"/templates/vpc.yaml", []byte(vpcTemplate), 0644)
+	require.NoError(t, err)
+	err = os.WriteFile(tmpDir+"/templates/app.yaml", []byte(appTemplate), 0644)
+	require.NoError(t, err)
+
+	// Mock deployer that expects two deployments
+	mockDeployer := &MockDeployer{}
+	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(stack *model.Stack) bool {
+		return stack.Name == "vpc"
+	})).Return(nil).Once()
+
+	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(stack *model.Stack) bool {
+		return stack.Name == "app"
+	})).Return(nil).Once()
+
+	oldDeployer := deployer
+	SetDeployer(mockDeployer)
+	defer SetDeployer(oldDeployer)
+
+	// Change to temp directory and execute
+	oldDir, _ := os.Getwd()
+	defer func() {
+		err := os.Chdir(oldDir)
+		require.NoError(t, err)
+	}()
+	err = os.Chdir(tmpDir)
+	require.NoError(t, err)
+
+	rootCmd.SetArgs([]string{"deploy", "test-context"})
+
+	err = rootCmd.Execute()
+	assert.NoError(t, err, "deploy command should successfully deploy all stacks")
+
+	// Verify both stacks were deployed
+	mockDeployer.AssertExpectations(t)
+}
+
+func TestDeployCommand_NoStacksInContext(t *testing.T) {
+	// Test that deploy command handles context with no stacks gracefully
+
+	// Create a temporary config file with no stacks
+	configContent := `
+project: test-project
+
+contexts:
+  empty-context:
+    region: us-east-1
+
+stacks: []
+`
+	tmpDir := t.TempDir()
+	configFile := tmpDir + "/stackaroo.yaml"
+	err := os.WriteFile(configFile, []byte(configContent), 0644)
+	require.NoError(t, err)
+
+	// Mock deployer that shouldn't be called
+	mockDeployer := &MockDeployer{}
+
+	oldDeployer := deployer
+	SetDeployer(mockDeployer)
+	defer SetDeployer(oldDeployer)
+
+	// Change to temp directory and execute
+	oldDir, _ := os.Getwd()
+	defer func() {
+		err := os.Chdir(oldDir)
+		require.NoError(t, err)
+	}()
+	err = os.Chdir(tmpDir)
+	require.NoError(t, err)
+
+	rootCmd.SetArgs([]string{"deploy", "empty-context"})
+
+	err = rootCmd.Execute()
+	assert.NoError(t, err, "deploy command should handle empty context without error")
 
 	// Verify no deployer calls were made
 	mockDeployer.AssertExpectations(t)

examples/simple-vpc/README.md

@@ -53,16 +53,28 @@ The `stackaroo.yaml` file defines:
 
 3. **Deploy to development** (shows preview before applying changes):
    ```bash
+   # Deploy all stacks in the dev context
+   ../../stackaroo deploy dev
+   
+   # Or deploy a specific stack
    ../../stackaroo deploy dev vpc
    ```
 
 4. **Deploy to staging** (shows preview before applying changes):
    ```bash
+   # Deploy all stacks in the staging context
+   ../../stackaroo deploy staging
+   
+   # Or deploy a specific stack
    ../../stackaroo deploy staging vpc
    ```
 
 5. **Deploy to production** (requires production account access):
    ```bash
+   # Deploy all stacks in the prod context
+   ../../stackaroo deploy prod
+   
+   # Or deploy a specific stack
    ../../stackaroo deploy prod vpc
    ```
 
@@ -118,13 +130,23 @@ Each deployment creates:
 
 Check the status of your deployments:
 ```bash
+# Check status of all stacks in context
+../../stackaroo status dev
+
+# Or check status of specific stack
 ../../stackaroo status dev vpc
 ```
 
 ## Cleanup
 
 To remove the infrastructure:
 ```bash
+# Delete all stacks in each context
+../../stackaroo delete dev
+../../stackaroo delete staging  
+../../stackaroo delete prod
+
+# Or delete specific stacks
 ../../stackaroo delete dev vpc
 ../../stackaroo delete staging vpc
 ../../stackaroo delete prod vpc

internal/config/file/provider.go

@@ -109,6 +109,26 @@ func (fp *Provider) GetStack(stackName, context string) (*config.StackConfig, er
 	return stack, nil
 }
 
+// ListStacks returns all available stack names for a specific context
+func (fp *Provider) ListStacks(context string) ([]string, error) {
+	if err := fp.ensureLoaded(); err != nil {
+		return nil, err
+	}
+
+	// Check if the context exists
+	if _, exists := fp.rawConfig.Contexts[context]; !exists {
+		return nil, fmt.Errorf("context '%s' not found in configuration", context)
+	}
+
+	// Extract stack names
+	stackNames := make([]string, 0, len(fp.rawConfig.Stacks))
+	for _, stack := range fp.rawConfig.Stacks {
+		stackNames = append(stackNames, stack.Name)
+	}
+
+	return stackNames, nil
+}
+
 // Validate checks the configuration for consistency and errors
 func (fp *Provider) Validate() error {
 	if err := fp.ensureLoaded(); err != nil {