feat: Path-based component resolution for all commands

cmd/cmd_utils.go

@@ -696,6 +696,38 @@ func getConfigAndStacksInfo(commandName string, cmd *cobra.Command, args []strin
 
 	info, err := e.ProcessCommandLineArgs(commandName, cmd, finalArgs, argsAfterDoubleDash)
 	errUtils.CheckErrorPrintAndExit(err, "", "")
+
+	// Resolve path-based component arguments to component names
+	if info.NeedsPathResolution && info.ComponentFromArg != "" {
+		atmosConfig, err := cfg.InitCliConfig(info, true)
+		if err != nil {
+			errUtils.CheckErrorPrintAndExit(fmt.Errorf("%w: %w", errUtils.ErrPathResolutionFailed, err), "", "")
+		}
+
+		resolvedComponent, err := e.ResolveComponentFromPath(
+			&atmosConfig,
+			info.ComponentFromArg,
+			info.Stack,
+			commandName, // Component type is the command name (terraform, helmfile, packer)
+		)
+		if err != nil {
+			errUtils.CheckErrorPrintAndExit(
+				fmt.Errorf("%w: %w", errUtils.ErrPathResolutionFailed, err),
+				"",
+				fmt.Sprintf("Hint: Make sure the path is within your component directories and the component exists in stack '%s'", info.Stack),
+			)
+		}
+
+		log.Debug("Resolved component from path",
+			"original_path", info.ComponentFromArg,
+			"resolved_component", resolvedComponent,
+			"stack", info.Stack,
+		)
+
+		info.ComponentFromArg = resolvedComponent
+		info.NeedsPathResolution = false // Mark as resolved
+	}
+
 	return info
 }
 
@@ -779,7 +811,49 @@ func showUsageExample(cmd *cobra.Command, details string) {
 func stackFlagCompletion(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	// If a component was provided as the first argument, filter stacks by that component.
 	if len(args) > 0 && args[0] != "" {
-		output, err := listStacksForComponent(args[0])
+		component := args[0]
+
+		// Check if argument is a path that needs resolution
+		// Paths are: ".", or contain path separators
+		if component == "." || strings.Contains(component, string(filepath.Separator)) {
+			// Attempt to resolve path to component name for stack filtering
+			// Use silent error handling - if resolution fails, just list all stacks (graceful degradation)
+			configAndStacksInfo := schema.ConfigAndStacksInfo{}
+			atmosConfig, err := cfg.InitCliConfig(configAndStacksInfo, true)
+			if err == nil {
+				// Determine component type from command
+				// Walk up command chain to find root command (terraform, helmfile, packer)
+				componentType := determineComponentTypeFromCommand(cmd)
+
+				// Try to resolve the path (without stack context for completion)
+				resolvedComponent, err := e.ResolveComponentFromPath(
+					&atmosConfig,
+					component,
+					"", // No stack context yet - we're completing the stack flag
+					componentType,
+				)
+				if err == nil {
+					component = resolvedComponent
+					log.Trace("Resolved path for stack completion",
+						"original", args[0],
+						"resolved", component,
+					)
+				} else {
+					// If resolution fails, fall through to list all stacks (graceful degradation)
+					log.Trace("Could not resolve path for stack completion, listing all stacks",
+						"path", component,
+						"error", err,
+					)
+					output, err := listStacks(cmd)
+					if err != nil {
+						return nil, cobra.ShellCompDirectiveNoFileComp
+					}
+					return output, cobra.ShellCompDirectiveNoFileComp
+				}
+			}
+		}
+
+		output, err := listStacksForComponent(component)
 		if err != nil {
 			return nil, cobra.ShellCompDirectiveNoFileComp
 		}
@@ -794,6 +868,25 @@ func stackFlagCompletion(cmd *cobra.Command, args []string, toComplete string) (
 	return output, cobra.ShellCompDirectiveNoFileComp
 }
 
+// determineComponentTypeFromCommand walks up the command chain to find the component type.
+func determineComponentTypeFromCommand(cmd *cobra.Command) string {
+	// Walk up to find the root component command (terraform, helmfile, packer).
+	current := cmd
+	for current != nil {
+		switch current.Name() {
+		case "terraform":
+			return "terraform"
+		case "helmfile":
+			return "helmfile"
+		case "packer":
+			return "packer"
+		}
+		current = current.Parent()
+	}
+	// Default to terraform if we can't determine
+	return "terraform"
+}
+
 // listStacksForComponent returns stacks that contain the specified component.
 // It initializes the CLI configuration, describes all stacks, and filters them
 // to include only those defining the given component.
@@ -877,6 +970,14 @@ func identityArgCompletion(cmd *cobra.Command, args []string, toComplete string)
 
 func ComponentsArgCompletion(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	if len(args) == 0 {
+		// Check if user is typing a path
+		// Enable directory completion for paths
+		if toComplete == "." || strings.Contains(toComplete, string(filepath.Separator)) {
+			log.Trace("Enabling directory completion for path input", "toComplete", toComplete)
+			return nil, cobra.ShellCompDirectiveFilterDirs
+		}
+
+		// Otherwise, suggest component names from stack configurations
 		output, err := listComponents(cmd)
 		if err != nil {
 			return nil, cobra.ShellCompDirectiveNoFileComp

cmd/describe_component.go

@@ -3,6 +3,8 @@ package cmd
 import (
 	"errors"
 	"os"
+	"path/filepath"
+	"strings"
 
 	"github.com/spf13/cobra"
 
@@ -71,6 +73,9 @@ var describeComponentCmd = &cobra.Command{
 
 		component := args[0]
 
+		// Check if argument is a path that needs resolution
+		needsPathResolution := component == "." || strings.Contains(component, string(filepath.Separator))
+
 		// Load atmos configuration to get auth config.
 		atmosConfig, err := cfg.InitCliConfig(schema.ConfigAndStacksInfo{
 			ComponentFromArg: component,
@@ -80,6 +85,26 @@ var describeComponentCmd = &cobra.Command{
 			return errors.Join(errUtils.ErrFailedToInitConfig, err)
 		}
 
+		// Resolve path-based component arguments to component names
+		if needsPathResolution {
+			if stack == "" {
+				return errors.New("--stack flag is required when using path-based component resolution")
+			}
+
+			// We don't know the component type yet - describe component detects it
+			// So we'll try to resolve the path without component type validation
+			// The component type will be validated during ExecuteDescribeComponent
+			resolvedComponent, err := e.ResolveComponentFromPathWithoutTypeCheck(
+				&atmosConfig,
+				component,
+				stack,
+			)
+			if err != nil {
+				return err
+			}
+			component = resolvedComponent
+		}
+
 		// Get identity from flag and create AuthManager if provided.
 		identityName := GetIdentityFromFlags(cmd, os.Args)
 		authManager, err := CreateAuthManagerFromIdentity(identityName, &atmosConfig.Auth)

cmd/validate_component.go

@@ -1,10 +1,16 @@
 package cmd
 
 import (
+	"errors"
+	"path/filepath"
+	"strings"
+
 	"github.com/spf13/cobra"
 
 	errUtils "github.com/cloudposse/atmos/errors"
 	e "github.com/cloudposse/atmos/internal/exec"
+	cfg "github.com/cloudposse/atmos/pkg/config"
+	"github.com/cloudposse/atmos/pkg/schema"
 )
 
 // validateComponentCmd validates atmos components
@@ -19,6 +25,46 @@ var validateComponentCmd = &cobra.Command{
 		// Check Atmos configuration
 		checkAtmosConfig()
 
+		// Handle path-based component resolution
+		if len(args) > 0 {
+			component := args[0]
+			needsPathResolution := component == "." || strings.Contains(component, string(filepath.Separator))
+
+			if needsPathResolution {
+				flags := cmd.Flags()
+				stack, err := flags.GetString("stack")
+				if err != nil {
+					return err
+				}
+
+				if stack == "" {
+					return errors.New("--stack flag is required when using path-based component resolution")
+				}
+
+				// Load atmos configuration
+				atmosConfig, err := cfg.InitCliConfig(schema.ConfigAndStacksInfo{
+					ComponentFromArg: component,
+					Stack:            stack,
+				}, false)
+				if err != nil {
+					return err
+				}
+
+				// Resolve path to component name (without type check - validate detects type)
+				resolvedComponent, err := e.ResolveComponentFromPathWithoutTypeCheck(
+					&atmosConfig,
+					component,
+					stack,
+				)
+				if err != nil {
+					return err
+				}
+
+				// Replace the argument with the resolved component name
+				args[0] = resolvedComponent
+			}
+		}
+
 		_, _, err := e.ExecuteValidateComponentCmd(cmd, args)
 		if err != nil {
 			return err