feat: Adding support for values

Author: yhakbar

internal/cli/commands/catalog/tui/redesign/component_discovery.go

@@ -35,8 +35,8 @@ const (
 // surfaced as separate components.
 //
 // Unlike the legacy module.Repo.FindModules walker (which only scans the
-// `modules/` convention), this walks the entire repo — templates may live
-// anywhere, and the redesign treats module/template discovery uniformly.
+// `modules/` convention), this walks the entire repo, since templates may
+// live anywhere and the redesign treats all component kinds uniformly.
 //
 // Construct one via NewComponentDiscovery, customize it with the With*
 // methods, then call Discover on a repo.

internal/cli/commands/catalog/tui/redesign/component_discovery_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/gruntwork-io/terragrunt/internal/cli/commands/catalog/tui/redesign"
+
 	"github.com/gruntwork-io/terragrunt/internal/services/catalog/module"
 	"github.com/gruntwork-io/terragrunt/test/helpers"
 	"github.com/gruntwork-io/terragrunt/test/helpers/logger"
@@ -58,14 +59,14 @@ func TestDiscoverComponents_ClassifiesFixtureTree(t *testing.T) {
 	// foo/ is a plain module (has main.tf, no boilerplate).
 	writeFile(t, filepath.Join(repoDir, "foo", "main.tf"), "# vpc terraform")
 
-	// bar/ has a .boilerplate/ subdir — template at bar/.
+	// bar/ has a .boilerplate/ subdir. Template at bar/.
 	writeFile(t, filepath.Join(repoDir, "bar", ".boilerplate", "boilerplate.yml"), "variables: []\n")
 	writeFile(t, filepath.Join(repoDir, "bar", ".boilerplate", "README.md"), "# bar template boilerplate dir")
 
-	// baz/ has a top-level boilerplate.yml — template at baz/.
+	// baz/ has a top-level boilerplate.yml. Template at baz/.
 	writeFile(t, filepath.Join(repoDir, "baz", "boilerplate.yml"), "variables: []\n")
 
-	// qux/ has both main.tf AND a .boilerplate/ — template wins.
+	// qux/ has both main.tf AND a .boilerplate/. Template wins.
 	writeFile(t, filepath.Join(repoDir, "qux", "main.tf"), "# mixed")
 	writeFile(t, filepath.Join(repoDir, "qux", ".boilerplate", "boilerplate.yml"), "variables: []\n")
 
@@ -128,11 +129,11 @@ func TestDiscoverComponents_UnitsAndStacks(t *testing.T) {
 	writeFile(t, filepath.Join(repoDir, "mixed-stack", "terragrunt.stack.hcl"), "# stack")
 	writeFile(t, filepath.Join(repoDir, "mixed-stack", "terragrunt.hcl"), "# also present")
 
-	// A nested .tf file under a unit must NOT surface as a second module —
-	// the unit's subtree is SkipDir'd.
+	// A nested .tf file under a unit must NOT surface as a second module.
+	// The unit's subtree is SkipDir'd.
 	writeFile(t, filepath.Join(repoDir, "unit-a", "nested", "main.tf"), "# should not surface")
 
-	// A nested unit under a stack must NOT surface — the stack's subtree is
+	// A nested unit under a stack must NOT surface. The stack's subtree is
 	// SkipDir'd.
 	writeFile(t, filepath.Join(repoDir, "stack-a", "generated", "terragrunt.hcl"), "# should not surface")
 

internal/cli/commands/catalog/tui/redesign/copy.go

@@ -11,59 +11,93 @@ import (
 	"github.com/gruntwork-io/terragrunt/pkg/options"
 )
 
-// copyCmd is a tea.ExecCommand that copies a unit or stack component's
+// CopyCmd is a tea.ExecCommand that copies a unit or stack component's
 // directory tree into the user's working directory. Unlike scaffold, it does
-// not generate a new terragrunt.hcl — it simply materializes the component's
-// files so the user can edit them in place.
-type copyCmd struct {
+// not generate a new terragrunt.hcl; it materializes the component's files
+// so the user can edit them in place.
+type CopyCmd struct {
 	component *Component
 	opts      *options.TerragruntOptions
 	logger    log.Logger
+	result    copyResult
 }
 
-func newCopyCmd(logger log.Logger, opts *options.TerragruntOptions, c *Component) *copyCmd {
-	return &copyCmd{component: c, opts: opts, logger: logger}
+// copyResult records what the copy step did beyond the raw file copy, so the
+// TUI can surface an appropriate exit message to the user.
+type copyResult struct { //nolint:govet // field order favors readability over GC-scan bytes
+	references    ValuesReferences
+	workingDir    string
+	valuesWritten bool
+	valuesSkipped bool
 }
 
-func (c *copyCmd) Run() error {
+func NewCopyCmd(logger log.Logger, opts *options.TerragruntOptions, c *Component) *CopyCmd {
+	return &CopyCmd{component: c, opts: opts, logger: logger}
+}
+
+func (c *CopyCmd) Run() error {
 	src, dst, err := c.resolvePaths()
 	if err != nil {
 		return err
 	}
 
 	c.logger.Debugf("Copying component %q to %q", src, dst)
 
-	return copyDir(src, dst)
-}
+	if err := copyDir(src, dst); err != nil {
+		return err
+	}
+
+	c.result.workingDir = dst
 
-func (c *copyCmd) SetStdin(io.Reader)  {}
-func (c *copyCmd) SetStdout(io.Writer) {}
-func (c *copyCmd) SetStderr(io.Writer) {}
+	configName := configFileForKind(c.component.Kind)
+	if configName == "" {
+		return nil
+	}
+
+	refs, err := CollectValuesReferences(filepath.Join(src, configName))
+	if err != nil {
+		return err
+	}
 
-// CopyCmdRunner is the test-visible contract for the copy command — it
-// exposes Run() so tests can execute the command without a full TUI loop.
-type CopyCmdRunner interface {
-	Run() error
+	if refs.IsEmpty() {
+		return nil
+	}
+
+	c.result.references = refs
+
+	written, err := WriteValuesStub(dst, refs)
+	if err != nil {
+		return err
+	}
+
+	c.result.valuesWritten = written
+	c.result.valuesSkipped = !written
+
+	return nil
 }
 
-// NewCopyCmdForTest constructs a CopyCmdRunner for use in tests. It is
-// intentionally kept to a narrow surface so tests don't depend on internals.
-func NewCopyCmdForTest(logger log.Logger, opts *options.TerragruntOptions, c *Component) CopyCmdRunner {
-	return newCopyCmd(logger, opts, c)
+// Result exposes the outcome of the last Run call. Intended for the TUI
+// update loop to format an exit message; tests may use it too.
+func (c *CopyCmd) Result() copyResult {
+	return c.result
 }
 
+func (c *CopyCmd) SetStdin(io.Reader)  {}
+func (c *CopyCmd) SetStdout(io.Writer) {}
+func (c *CopyCmd) SetStderr(io.Writer) {}
+
 // resolvePaths returns the absolute source directory (inside the cloned repo)
 // and the destination directory (the user's working directory) for this copy.
 // Files from src are materialized directly into the working directory so the
 // action mirrors how scaffold emits its output.
-func (c *copyCmd) resolvePaths() (string, string, error) {
+func (c *CopyCmd) resolvePaths() (string, string, error) {
 	if c.component == nil || c.component.Repo == nil {
-		return "", "", errors.New("copyCmd: nil component or repo")
+		return "", "", errors.New("CopyCmd: nil component or repo")
 	}
 
 	repoPath := c.component.Repo.Path()
 	if repoPath == "" {
-		return "", "", errors.New("copyCmd: empty repo path")
+		return "", "", errors.New("CopyCmd: empty repo path")
 	}
 
 	src := repoPath
@@ -73,7 +107,7 @@ func (c *copyCmd) resolvePaths() (string, string, error) {
 
 	workingDir := c.opts.WorkingDir
 	if workingDir == "" {
-		return "", "", errors.New("copyCmd: empty working directory")
+		return "", "", errors.New("CopyCmd: empty working directory")
 	}
 
 	return src, workingDir, nil

internal/cli/commands/catalog/tui/redesign/copy_test.go

@@ -1,7 +1,9 @@
 package redesign_test
 
 import (
+	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/gruntwork-io/terragrunt/internal/cli/commands/catalog/tui/redesign"
@@ -32,15 +34,92 @@ func TestCopyCmd_CopiesIntoWorkingDirectory(t *testing.T) {
 	opts := options.NewTerragruntOptions()
 	opts.WorkingDir = workingDir
 
-	cmd := redesign.NewCopyCmdForTest(logger.CreateLogger(), opts, components[0])
-	require.NoError(t, cmd.Run())
+	require.NoError(t, redesign.NewCopyCmd(logger.CreateLogger(), opts, components[0]).Run())
 
 	assert.FileExists(t, filepath.Join(workingDir, "terragrunt.hcl"))
 	assert.FileExists(t, filepath.Join(workingDir, "inputs.hcl"))
 	assert.NoFileExists(t, filepath.Join(workingDir, ".terragrunt-cache", "junk.txt"))
 	assert.NoDirExists(t, filepath.Join(workingDir, ".terragrunt-cache"))
 }
 
+func TestCopyCmd_WritesValuesStubForUnit(t *testing.T) {
+	t.Parallel()
+
+	repoDir := helpers.TmpDirWOSymlinks(t)
+
+	unitBody := `
+locals {
+  region = values.region
+}
+
+inputs = {
+  app = values.app
+  env = values.env
+}
+`
+	writeFile(t, filepath.Join(repoDir, "vpc", "terragrunt.hcl"), unitBody)
+
+	repo := newFakeRepo(t, repoDir)
+
+	components, err := redesign.NewComponentDiscovery().Discover(repo)
+	require.NoError(t, err)
+	require.Len(t, components, 1)
+
+	workingDir := t.TempDir()
+	opts := options.NewTerragruntOptions()
+	opts.WorkingDir = workingDir
+
+	require.NoError(t, redesign.NewCopyCmd(logger.CreateLogger(), opts, components[0]).Run())
+
+	valuesPath := filepath.Join(workingDir, "terragrunt.values.hcl")
+	assert.FileExists(t, valuesPath)
+
+	raw, err := os.ReadFile(valuesPath)
+	require.NoError(t, err)
+
+	content := string(raw)
+	assert.Contains(t, content, "# Auto-generated by `terragrunt catalog`")
+
+	appIdx := strings.Index(content, "\napp")
+
+	envIdx := strings.Index(content, "\nenv")
+
+	regionIdx := strings.Index(content, "\nregion")
+
+	require.NotEqual(t, -1, appIdx)
+	require.NotEqual(t, -1, envIdx)
+	require.NotEqual(t, -1, regionIdx)
+	assert.Less(t, appIdx, envIdx)
+	assert.Less(t, envIdx, regionIdx)
+}
+
+func TestCopyCmd_LeavesExistingValuesFileAlone(t *testing.T) {
+	t.Parallel()
+
+	repoDir := helpers.TmpDirWOSymlinks(t)
+	writeFile(t, filepath.Join(repoDir, "vpc", "terragrunt.hcl"),
+		`locals { region = values.region }`)
+
+	repo := newFakeRepo(t, repoDir)
+
+	components, err := redesign.NewComponentDiscovery().Discover(repo)
+	require.NoError(t, err)
+	require.Len(t, components, 1)
+
+	workingDir := t.TempDir()
+	existing := []byte(`region = "us-east-1"` + "\n")
+	require.NoError(t, os.WriteFile(filepath.Join(workingDir, "terragrunt.values.hcl"), existing, 0o644))
+
+	opts := options.NewTerragruntOptions()
+	opts.WorkingDir = workingDir
+
+	require.NoError(t, redesign.NewCopyCmd(logger.CreateLogger(), opts, components[0]).Run())
+
+	got, err := os.ReadFile(filepath.Join(workingDir, "terragrunt.values.hcl"))
+	require.NoError(t, err)
+	assert.Equal(t, existing, got, "pre-existing values file should be untouched")
+}
+
 func TestCopyCmd_RefusesToOverwriteExistingFile(t *testing.T) {
 	t.Parallel()
 
@@ -59,8 +138,7 @@ func TestCopyCmd_RefusesToOverwriteExistingFile(t *testing.T) {
 	opts := options.NewTerragruntOptions()
 	opts.WorkingDir = workingDir
 
-	cmd := redesign.NewCopyCmdForTest(logger.CreateLogger(), opts, components[0])
-	err = cmd.Run()
+	err = redesign.NewCopyCmd(logger.CreateLogger(), opts, components[0]).Run()
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "already exists")
 }

internal/cli/commands/catalog/tui/redesign/model.go

@@ -61,6 +61,7 @@ type Model struct {
 	pagerKeys           tui.PagerKeyMap
 	listKeys            list.KeyMap
 	currentPagerButtons []button
+	exitMessage         string
 	viewport            viewport.Model
 	activeButton        button
 	State               sessionState
@@ -72,6 +73,14 @@ type Model struct {
 	userNavigated       bool
 }
 
+// ExitMessage returns the styled post-exit message the model set while
+// handling its final action (e.g., a successful copy that generated a
+// terragrunt.values.hcl file). The caller is responsible for printing it
+// after the tea.Program returns, once the alt screen has been torn down.
+func (m Model) ExitMessage() string { //nolint:gocritic
+	return m.exitMessage
+}
+
 // List returns the currently active list — the one filtered by the active
 // tab. Exposed for tests and view code that need to inspect items.
 func (m Model) List() list.Model { //nolint:gocritic