chore(helm/v2-aplha): Add --input-dir flag to helm/v2-alpha plugin to allow operating on projects in different directories

Generated-by: Claude

Author: camilamacedo86

docs/book/src/plugins/available/helm-v2-alpha.md

@@ -690,7 +690,8 @@ The Makefile targets use sensible defaults extracted from your project configura
 | Flag                | Description                                                                 |
 |---------------------|-----------------------------------------------------------------------------|
 | **--manifests**     | Path to YAML file containing Kubernetes manifests (default: `dist/install.yaml`) |
-| **--output-dir** string | Output directory for chart (default: `dist`)                                |
+| **--output-dir**    | Output directory for chart (default: `dist`)                                |
+| **--input-dir**     | Path to directory containing PROJECT file. All operations will use files from this directory |
 | **--force**         | Regenerates preserved files except `Chart.yaml` (`values.yaml`, `NOTES.txt`, `_helpers.tpl`, `.helmignore`, `test-chart.yml`) |
 
 <aside class="note" role="note">

pkg/cli/cli.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	log "log/slog"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/spf13/afero"
@@ -611,6 +612,71 @@ func (c CLI) Run() error {
 	return nil
 }
 
+// handleInputDirForEdit checks if --input-dir flag is set for edit command and changes directory if needed.
+// This must run BEFORE the framework loads PROJECT file.
+func (c *CLI) handleInputDirForEdit(cmd *cobra.Command, subcommands []keySubcommandTuple) error {
+	// Check if --input-dir flag exists and is set
+	inputDirFlag := cmd.Flags().Lookup("input-dir")
+	if inputDirFlag == nil || !inputDirFlag.Changed {
+		return nil
+	}
+
+	inputDir := inputDirFlag.Value.String()
+	if inputDir == "" {
+		return nil
+	}
+
+	// Validate that at least one plugin supports --input-dir
+	// Currently only helm.kubebuilder.io/v2-alpha is allowed
+	hasAllowedPlugin := false
+	for _, tuple := range subcommands {
+		if tuple.key == "helm.kubebuilder.io/v2-alpha" {
+			hasAllowedPlugin = true
+			break
+		}
+	}
+
+	if !hasAllowedPlugin {
+		return fmt.Errorf("--input-dir flag is only supported with helm.kubebuilder.io/v2-alpha plugin")
+	}
+
+	// Resolve to absolute path
+	if !filepath.IsAbs(inputDir) {
+		absPath, err := filepath.Abs(inputDir)
+		if err != nil {
+			return fmt.Errorf("failed to resolve input-dir %q: %w", inputDir, err)
+		}
+		inputDir = absPath
+	}
+
+	// Validate directory exists
+	if info, err := os.Stat(inputDir); err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("input-dir does not exist: %q", inputDir)
+		}
+		return fmt.Errorf("failed to access input-dir %q: %w", inputDir, err)
+	} else if !info.IsDir() {
+		return fmt.Errorf("input-dir is not a directory: %q", inputDir)
+	}
+
+	// Validate PROJECT file exists in input-dir
+	projectFilePath := filepath.Join(inputDir, yamlstore.DefaultPath)
+	if _, err := os.Stat(projectFilePath); err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("input-dir does not contain %q: %q", yamlstore.DefaultPath, inputDir)
+		}
+		return fmt.Errorf("failed to access project file %q: %w", projectFilePath, err)
+	}
+
+	// Change working directory
+	if err := os.Chdir(inputDir); err != nil {
+		return fmt.Errorf("failed to change to input-dir %q: %w", inputDir, err)
+	}
+
+	log.Info("Operating in input directory", "path", inputDir)
+	return nil
+}
+
 // Command returns the underlying root command.
 func (c CLI) Command() *cobra.Command {
 	return c.cmd

pkg/cli/cli_test.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"strings"
 
 	. "github.com/onsi/ginkgo/v2"
@@ -807,4 +808,140 @@ plugins:
 			})
 		})
 	})
+
+	Context("handleInputDirForEdit", func() {
+		var (
+			c           *CLI
+			cmd         *cobra.Command
+			subcommands []keySubcommandTuple
+			tmpDir      string
+		)
+
+		BeforeEach(func() {
+			c = &CLI{}
+			cmd = &cobra.Command{}
+			cmd.Flags().String("input-dir", "", "test input-dir flag")
+
+			// Create a temporary directory for testing
+			var err error
+			tmpDir, err = os.MkdirTemp("", "cli-input-dir-test-*")
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		AfterEach(func() {
+			if tmpDir != "" {
+				_ = os.RemoveAll(tmpDir)
+			}
+		})
+
+		It("should return nil when input-dir flag is not set", func() {
+			subcommands = []keySubcommandTuple{
+				{key: "helm.kubebuilder.io/v2-alpha"},
+			}
+			err := c.handleInputDirForEdit(cmd, subcommands)
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It("should return nil when input-dir flag is empty", func() {
+			_ = cmd.Flags().Set("input-dir", "")
+			subcommands = []keySubcommandTuple{
+				{key: "helm.kubebuilder.io/v2-alpha"},
+			}
+			err := c.handleInputDirForEdit(cmd, subcommands)
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It("should return error when plugin is not helm/v2-alpha", func() {
+			_ = cmd.Flags().Set("input-dir", tmpDir)
+			subcommands = []keySubcommandTuple{
+				{key: "go.kubebuilder.io/v4"},
+			}
+			err := c.handleInputDirForEdit(cmd, subcommands)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("only supported with helm.kubebuilder.io/v2-alpha"))
+		})
+
+		It("should return error when directory does not exist", func() {
+			_ = cmd.Flags().Set("input-dir", "/nonexistent/path/to/dir")
+			subcommands = []keySubcommandTuple{
+				{key: "helm.kubebuilder.io/v2-alpha"},
+			}
+			err := c.handleInputDirForEdit(cmd, subcommands)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("does not exist"))
+		})
+
+		It("should return error when path is not a directory", func() {
+			// Create a file instead of directory
+			filePath := filepath.Join(tmpDir, "testfile")
+			err := os.WriteFile(filePath, []byte("test"), 0o644)
+			Expect(err).NotTo(HaveOccurred())
+
+			_ = cmd.Flags().Set("input-dir", filePath)
+			subcommands = []keySubcommandTuple{
+				{key: "helm.kubebuilder.io/v2-alpha"},
+			}
+			err = c.handleInputDirForEdit(cmd, subcommands)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("not a directory"))
+		})
+
+		It("should return error when directory does not contain PROJECT file", func() {
+			// Create directory without PROJECT file
+			emptyDir := filepath.Join(tmpDir, "empty-dir")
+			err := os.MkdirAll(emptyDir, 0o755)
+			Expect(err).NotTo(HaveOccurred())
+
+			_ = cmd.Flags().Set("input-dir", emptyDir)
+			subcommands = []keySubcommandTuple{
+				{key: "helm.kubebuilder.io/v2-alpha"},
+			}
+			err = c.handleInputDirForEdit(cmd, subcommands)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("does not contain"))
+			Expect(err.Error()).To(ContainSubstring("PROJECT"))
+		})
+
+		It("should change directory when helm plugin is present and dir exists", func() {
+			By("saving original directory")
+			originalDir, err := os.Getwd()
+			Expect(err).NotTo(HaveOccurred())
+			defer func() {
+				_ = os.Chdir(originalDir)
+			}()
+
+			By("creating PROJECT file in input directory")
+			projectPath := filepath.Join(tmpDir, "PROJECT")
+			projectContent := `domain: example.com
+layout:
+- go.kubebuilder.io/v4
+projectName: test-project
+repo: example.com/test-project
+version: "3"
+`
+			err = os.WriteFile(projectPath, []byte(projectContent), 0o644)
+			Expect(err).NotTo(HaveOccurred())
+
+			_ = cmd.Flags().Set("input-dir", tmpDir)
+			subcommands = []keySubcommandTuple{
+				{key: "helm.kubebuilder.io/v2-alpha"},
+			}
+
+			By("calling handleInputDirForEdit")
+			err = c.handleInputDirForEdit(cmd, subcommands)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("verifying directory changed")
+			currentDir, err := os.Getwd()
+			Expect(err).NotTo(HaveOccurred())
+
+			By("resolving symlinks for comparison")
+			expectedDir, err := filepath.EvalSymlinks(tmpDir)
+			Expect(err).NotTo(HaveOccurred())
+			actualDir, err := filepath.EvalSymlinks(currentDir)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(actualDir).To(Equal(expectedDir))
+		})
+	})
 })

pkg/cli/edit.go

@@ -14,7 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-//nolint:dupl
 package cli
 
 import (
@@ -63,6 +62,18 @@ func (c CLI) newEditCmd() *cobra.Command {
 
 	c.applySubcommandHooks(cmd, subcommands, editErrorMsg, false)
 
+	// Wrap PreRunE to handle --input-dir flag BEFORE framework loads PROJECT
+	frameworkPreRunE := cmd.PreRunE
+	cmd.PreRunE = func(cmd *cobra.Command, args []string) error {
+		if err := c.handleInputDirForEdit(cmd, subcommands); err != nil {
+			return err
+		}
+		if frameworkPreRunE != nil {
+			return frameworkPreRunE(cmd, args)
+		}
+		return nil
+	}
+
 	// Append plugin table after metadata updates
 	c.appendPluginTable(cmd, func(p plugin.Plugin) bool {
 		_, isValid := p.(plugin.Edit)

pkg/plugins/optional/helm/v2alpha/edit.go

@@ -52,6 +52,7 @@ type editSubcommand struct {
 	force         bool
 	manifestsFile string
 	outputDir     string
+	inputDir      string
 }
 
 //nolint:lll
@@ -76,6 +77,9 @@ distribution of your project. When enabled, adds Helm helpers targets to Makefil
 # Generate from custom manifests to custom output directory
   %[1]s edit --plugins=%[2]s --manifests=manifests/install.yaml --output-dir=helm-charts
 
+# Work with a project in a different directory (useful for monorepos)
+  %[1]s edit --plugins=%[2]s --input-dir=./path/to/project
+
 # Typical workflow:
   make build-installer  # Generate dist/install.yaml with latest changes
   %[1]s edit --plugins=%[2]s  # Generate/update Helm chart in dist/chart/
@@ -105,10 +109,16 @@ func (p *editSubcommand) BindFlags(fs *pflag.FlagSet) {
 	fs.BoolVar(&p.force, "force", false, "if true, regenerates all the files")
 	fs.StringVar(&p.manifestsFile, "manifests", DefaultManifestsFile,
 		"path to the YAML file containing Kubernetes manifests from kustomize output")
-	fs.StringVar(&p.outputDir, "output-dir", DefaultOutputDir, "output directory for the generated Helm chart")
+	fs.StringVar(&p.outputDir, "output-dir", DefaultOutputDir,
+		"output directory for the generated Helm chart")
+	fs.StringVar(&p.inputDir, "input-dir", "",
+		"path to directory containing PROJECT file; "+
+			"all operations will use files from this directory (defaults to current working directory)")
 }
 
 func (p *editSubcommand) InjectConfig(c config.Config) error {
+	// The --input-dir flag is handled by handleInputDirForEdit in pkg/cli/cli.go
+	// before this method is called, so the working directory is already set.
 	p.config = c
 	return nil
 }