Merge branch 'main' into feature/dev-3755-custom-component-types

Author: osterman

.golangci.yml

@@ -316,6 +316,16 @@ linters:
           - forbidigo
         path: _test\.go$
         text: "viper\\.BindEnv|viper\\.BindPFlag"
+      # These files are temporarily over the 500-line limit due to terraform caching refactoring.
+      # TODO: Refactor these files to reduce their size.
+      - linters:
+          - revive
+        path: internal/exec/terraform\.go$
+        text: "file-length-limit"
+      - linters:
+          - revive
+        path: internal/exec/terraform_clean\.go$
+        text: "file-length-limit"
     paths:
       - experiments/.*
       - third_party$

CLAUDE.md

@@ -19,6 +19,18 @@ This repository uses git worktrees for parallel development. When working in a w
 
 **For Task agents:** When searching for files, always use the current working directory (`.`) or relative paths. Never construct absolute paths that might escape the worktree.
 
+## Concurrent Sessions (MANDATORY)
+
+Multiple Claude sessions may be working on the same branch or worktree simultaneously. To avoid destroying other sessions' work:
+
+- **NEVER delete, reset, or discard files you didn't create** - Other sessions may have created them
+- **NEVER run `git reset`, `git checkout --`, or `git clean`** without explicit user approval
+- **ALWAYS ask the user before removing untracked files** - They may be work-in-progress from another session
+- **When you see unfamiliar files**, assume another session created them - ask the user what to do
+- **If pre-commit hooks fail due to files you didn't touch**, ask the user how to proceed rather than trying to fix or remove them
+
+**Why this matters:** The user may have multiple Claude sessions working in parallel on different aspects of a feature. Deleting “unknown” files destroys that work.
+
 ## Essential Commands
 
 ```bash

cmd/root.go

@@ -28,6 +28,8 @@ import (
 	"github.com/cloudposse/atmos/internal/tui/templates"
 	"github.com/cloudposse/atmos/internal/tui/templates/term"
 	cfg "github.com/cloudposse/atmos/pkg/config"
+	// Import adapters to register them with the config package.
+	_ "github.com/cloudposse/atmos/pkg/config/adapters"
 	"github.com/cloudposse/atmos/pkg/data"
 	"github.com/cloudposse/atmos/pkg/filesystem"
 	"github.com/cloudposse/atmos/pkg/flags"

cmd/terraform/clean.go

@@ -52,6 +52,7 @@ Common use cases:
 		everything := v.GetBool("everything")
 		skipLockFile := v.GetBool("skip-lock-file")
 		dryRun := v.GetBool("dry-run")
+		cache := v.GetBool("cache")
 
 		// Prompt for component/stack if neither is provided.
 		if component == "" && stack == "" {
@@ -78,6 +79,7 @@ Common use cases:
 			Everything:   everything,
 			SkipLockFile: skipLockFile,
 			DryRun:       dryRun,
+			Cache:        cache,
 		}
 		return e.ExecuteClean(opts, &atmosConfig)
 	},
@@ -89,9 +91,11 @@ func init() {
 		flags.WithBoolFlag("everything", "", false, "If set atmos will also delete the Terraform state files and directories for the component"),
 		flags.WithBoolFlag("force", "f", false, "Forcefully delete Terraform state files and directories without interaction"),
 		flags.WithBoolFlag("skip-lock-file", "", false, "Skip deleting the `.terraform.lock.hcl` file"),
+		flags.WithBoolFlag("cache", "", false, "Clean Terraform plugin cache directory"),
 		flags.WithEnvVars("everything", "ATMOS_TERRAFORM_CLEAN_EVERYTHING"),
 		flags.WithEnvVars("force", "ATMOS_TERRAFORM_CLEAN_FORCE"),
 		flags.WithEnvVars("skip-lock-file", "ATMOS_TERRAFORM_CLEAN_SKIP_LOCK_FILE"),
+		flags.WithEnvVars("cache", "ATMOS_TERRAFORM_CLEAN_CACHE"),
 	)
 
 	// Register flags with the command as persistent flags.

cmd/terraform/clean_test.go

@@ -0,0 +1,118 @@
+package terraform
+
+import (
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestCleanCommandSetup verifies that the clean command is properly configured.
+func TestCleanCommandSetup(t *testing.T) {
+	// Verify command is registered.
+	require.NotNil(t, cleanCmd)
+
+	// Verify it's attached to terraformCmd.
+	found := false
+	for _, cmd := range terraformCmd.Commands() {
+		if cmd.Name() == "clean" {
+			found = true
+			break
+		}
+	}
+	assert.True(t, found, "clean should be registered as a subcommand of terraformCmd")
+
+	// Verify command short and long descriptions.
+	assert.Contains(t, cleanCmd.Short, "Clean")
+	assert.Contains(t, cleanCmd.Long, "Terraform")
+}
+
+// TestCleanParserSetup verifies that the clean parser is properly configured.
+func TestCleanParserSetup(t *testing.T) {
+	require.NotNil(t, cleanParser, "cleanParser should be initialized")
+
+	// Verify the parser has the clean-specific flags.
+	registry := cleanParser.Registry()
+
+	expectedFlags := []string{
+		"everything",
+		"force",
+		"skip-lock-file",
+		"cache",
+	}
+
+	for _, flagName := range expectedFlags {
+		assert.True(t, registry.Has(flagName), "cleanParser should have %s flag registered", flagName)
+	}
+}
+
+// TestCleanFlagSetup verifies that clean command has correct flags registered.
+func TestCleanFlagSetup(t *testing.T) {
+	// Verify clean-specific flags are registered on the command.
+	cleanFlags := []string{
+		"everything",
+		"force",
+		"skip-lock-file",
+		"cache",
+	}
+
+	for _, flagName := range cleanFlags {
+		flag := cleanCmd.Flags().Lookup(flagName)
+		assert.NotNil(t, flag, "%s flag should be registered on clean command", flagName)
+	}
+}
+
+// TestCleanFlagDefaults verifies that clean command flags have correct default values.
+func TestCleanFlagDefaults(t *testing.T) {
+	v := viper.New()
+
+	// Bind parser to fresh viper instance.
+	err := cleanParser.BindToViper(v)
+	require.NoError(t, err)
+
+	// Verify default values.
+	assert.False(t, v.GetBool("everything"), "everything should default to false")
+	assert.False(t, v.GetBool("force"), "force should default to false")
+	assert.False(t, v.GetBool("skip-lock-file"), "skip-lock-file should default to false")
+	assert.False(t, v.GetBool("cache"), "cache should default to false")
+}
+
+// TestCleanFlagEnvVars verifies that clean command flags have environment variable bindings.
+func TestCleanFlagEnvVars(t *testing.T) {
+	registry := cleanParser.Registry()
+
+	// Expected env var bindings.
+	expectedEnvVars := map[string]string{
+		"everything":     "ATMOS_TERRAFORM_CLEAN_EVERYTHING",
+		"force":          "ATMOS_TERRAFORM_CLEAN_FORCE",
+		"skip-lock-file": "ATMOS_TERRAFORM_CLEAN_SKIP_LOCK_FILE",
+		"cache":          "ATMOS_TERRAFORM_CLEAN_CACHE",
+	}
+
+	for flagName, expectedEnvVar := range expectedEnvVars {
+		require.True(t, registry.Has(flagName), "cleanParser should have %s flag registered", flagName)
+		flag := registry.Get(flagName)
+		require.NotNil(t, flag, "cleanParser should have info for %s flag", flagName)
+		envVars := flag.GetEnvVars()
+		assert.Contains(t, envVars, expectedEnvVar, "%s should be bound to %s", flagName, expectedEnvVar)
+	}
+}
+
+// TestCleanCommandArgs verifies that clean command accepts the correct number of arguments.
+func TestCleanCommandArgs(t *testing.T) {
+	// The command should accept 0 or 1 argument (component name is optional).
+	require.NotNil(t, cleanCmd.Args)
+
+	// Verify with no args.
+	err := cleanCmd.Args(cleanCmd, []string{})
+	assert.NoError(t, err, "clean command should accept 0 arguments")
+
+	// Verify with one arg.
+	err = cleanCmd.Args(cleanCmd, []string{"my-component"})
+	assert.NoError(t, err, "clean command should accept 1 argument")
+
+	// Verify with two args (should fail).
+	err = cleanCmd.Args(cleanCmd, []string{"arg1", "arg2"})
+	assert.Error(t, err, "clean command should reject more than 1 argument")
+}

cmd/terraform/output.go

@@ -1,32 +1,195 @@
 package terraform
 
 import (
+	"slices"
+	"strings"
+
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 
 	"github.com/cloudposse/atmos/cmd/internal"
+	errUtils "github.com/cloudposse/atmos/errors"
+	exec "github.com/cloudposse/atmos/internal/exec"
+	cfg "github.com/cloudposse/atmos/pkg/config"
+	"github.com/cloudposse/atmos/pkg/data"
+	"github.com/cloudposse/atmos/pkg/flags"
+	"github.com/cloudposse/atmos/pkg/flags/compat"
+	"github.com/cloudposse/atmos/pkg/perf"
+	"github.com/cloudposse/atmos/pkg/schema"
+	tfoutput "github.com/cloudposse/atmos/pkg/terraform/output"
 )
 
+// outputParser handles flag parsing for output command.
+var outputParser *flags.StandardParser
+
 // outputCmd represents the terraform output command.
 var outputCmd = &cobra.Command{
 	Use:   "output",
 	Short: "Show output values from your root module",
-	Long: `Read an output variable from the state file.
+	Long: `Read output variables from the state file.
+
+When --format is specified, retrieves all outputs and formats them in the specified format.
+Without --format, passes through to native terraform/tofu output command.
 
 For complete Terraform/OpenTofu documentation, see:
   https://developer.hashicorp.com/terraform/cli/commands/output
   https://opentofu.org/docs/cli/commands/output`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return terraformRun(terraformCmd, cmd, args)
+		v := viper.GetViper()
+		if err := terraformParser.BindFlagsToViper(cmd, v); err != nil {
+			return err
+		}
+		if err := outputParser.BindFlagsToViper(cmd, v); err != nil {
+			return err
+		}
+		format := v.GetString("format")
+		if format == "" {
+			return terraformRun(terraformCmd, cmd, args)
+		}
+		return outputRunWithFormat(cmd, args, format)
 	},
 }
 
+// outputRunWithFormat executes terraform output with atmos formatting.
+func outputRunWithFormat(cmd *cobra.Command, args []string, format string) error {
+	defer perf.Track(nil, "terraform.outputRunWithFormat")()
+
+	if err := validateOutputFormat(format); err != nil {
+		return err
+	}
+	info, atmosConfig, err := prepareOutputContext(cmd, args)
+	if err != nil {
+		return err
+	}
+	return executeOutputWithFormat(atmosConfig, info, format)
+}
+
+// validateOutputFormat checks if the format is supported.
+func validateOutputFormat(format string) error {
+	if !slices.Contains(tfoutput.SupportedFormats, format) {
+		return errUtils.Build(errUtils.ErrInvalidArgumentError).
+			WithExplanationf("Invalid --format value %q.", format).
+			WithHintf("Supported formats: %s.", strings.Join(tfoutput.SupportedFormats, ", ")).
+			Err()
+	}
+	return nil
+}
+
+// prepareOutputContext validates config and prepares component info.
+func prepareOutputContext(cmd *cobra.Command, args []string) (*schema.ConfigAndStacksInfo, *schema.AtmosConfiguration, error) {
+	if err := internal.ValidateAtmosConfig(); err != nil {
+		return nil, nil, err
+	}
+	separatedArgs := compat.GetSeparated()
+	argsWithSubCommand := append([]string{"output"}, args...)
+	info, err := exec.ProcessCommandLineArgs(cfg.TerraformComponentType, terraformCmd, argsWithSubCommand, separatedArgs)
+	if err != nil {
+		return nil, nil, err
+	}
+	if err := resolveAndPromptForArgs(&info, cmd); err != nil {
+		return nil, nil, err
+	}
+	v := viper.GetViper()
+	globalFlags := flags.ParseGlobalFlags(cmd, v)
+	configAndStacksInfo := schema.ConfigAndStacksInfo{
+		AtmosBasePath:           globalFlags.BasePath,
+		AtmosConfigFilesFromArg: globalFlags.Config,
+		AtmosConfigDirsFromArg:  globalFlags.ConfigPath,
+		ProfilesFromArg:         globalFlags.Profile,
+		ComponentFromArg:        info.ComponentFromArg,
+		Stack:                   info.Stack,
+	}
+	atmosConfig, err := cfg.InitCliConfig(configAndStacksInfo, true)
+	if err != nil {
+		return nil, nil, errUtils.Build(errUtils.ErrInitializeCLIConfig).WithCause(err).Err()
+	}
+	return &info, &atmosConfig, nil
+}
+
+// executeOutputWithFormat retrieves and formats terraform outputs.
+func executeOutputWithFormat(atmosConfig *schema.AtmosConfiguration, info *schema.ConfigAndStacksInfo, format string) error {
+	v := viper.GetViper()
+	skipInit := v.GetBool("skip-init")
+	outputFile := v.GetString("output-file")
+	uppercase := v.GetBool("uppercase")
+	flatten := v.GetBool("flatten")
+
+	outputs, err := tfoutput.GetComponentOutputs(atmosConfig, info.ComponentFromArg, info.Stack, skipInit)
+	if err != nil {
+		return errUtils.Build(errUtils.ErrTerraformOutputFailed).
+			WithCause(err).
+			WithExplanationf("Failed to get terraform outputs for component %q in stack %q.", info.ComponentFromArg, info.Stack).
+			Err()
+	}
+
+	// Build format options.
+	opts := tfoutput.FormatOptions{
+		Uppercase: uppercase,
+		Flatten:   flatten,
+	}
+
+	// Check if a specific output name was requested (in AdditionalArgsAndFlags).
+	outputName := extractOutputName(info.AdditionalArgsAndFlags)
+	var formatted string
+	if outputName != "" {
+		formatted, err = formatSingleOutput(outputs, outputName, format, opts)
+	} else {
+		formatted, err = tfoutput.FormatOutputsWithOptions(outputs, tfoutput.Format(format), opts)
+	}
+	if err != nil {
+		return err
+	}
+
+	if outputFile != "" {
+		return tfoutput.WriteToFile(outputFile, formatted)
+	}
+	return data.Write(formatted)
+}
+
+// extractOutputName extracts the output name from additional args.
+// Output name is a positional arg that doesn't start with "-".
+func extractOutputName(args []string) string {
+	for _, arg := range args {
+		if !strings.HasPrefix(arg, "-") {
+			return arg
+		}
+	}
+	return ""
+}
+
+// formatSingleOutput formats a single output value.
+func formatSingleOutput(outputs map[string]any, outputName, format string, opts tfoutput.FormatOptions) (string, error) {
+	value, exists := outputs[outputName]
+	if !exists {
+		return "", errUtils.Build(errUtils.ErrTerraformOutputFailed).
+			WithExplanationf("Output %q not found.", outputName).
+			WithHint("Use 'atmos terraform output <component> -s <stack>' without an output name to see all available outputs.").
+			Err()
+	}
+	return tfoutput.FormatSingleValueWithOptions(outputName, value, tfoutput.Format(format), opts)
+}
+
 func init() {
-	// Register completions for outputCmd.
+	outputParser = flags.NewStandardParser(
+		flags.WithStringFlag("format", "f", "", "Output format: json, yaml, hcl, env, dotenv, bash, csv, tsv"),
+		flags.WithStringFlag("output-file", "o", "", "Write output to file instead of stdout"),
+		flags.WithBoolFlag("uppercase", "u", false, "Convert keys to uppercase (useful for env vars)"),
+		flags.WithBoolFlag("flatten", "", false, "Flatten nested maps into key_subkey format"),
+		flags.WithEnvVars("format", "ATMOS_TERRAFORM_OUTPUT_FORMAT"),
+		flags.WithEnvVars("output-file", "ATMOS_TERRAFORM_OUTPUT_FILE"),
+		flags.WithEnvVars("uppercase", "ATMOS_TERRAFORM_OUTPUT_UPPERCASE"),
+		flags.WithEnvVars("flatten", "ATMOS_TERRAFORM_OUTPUT_FLATTEN"),
+	)
+	outputParser.RegisterFlags(outputCmd)
+	if err := outputParser.BindToViper(viper.GetViper()); err != nil {
+		panic(err)
+	}
+	if err := outputCmd.RegisterFlagCompletionFunc("format", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		return tfoutput.SupportedFormats, cobra.ShellCompDirectiveNoFileComp
+	}); err != nil {
+		_ = err
+	}
 	RegisterTerraformCompletions(outputCmd)
-
-	// Register compat flags for this subcommand.
 	internal.RegisterCommandCompatFlags("terraform", "output", OutputCompatFlags())
-
-	// Attach to parent terraform command.
 	terraformCmd.AddCommand(outputCmd)
 }