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"
@@ -99,6 +100,12 @@ func New(options ...Option) (*CLI, error) {
 		return nil, err
 	}
 
+	// Handle --input-dir flag before building the command tree.
+	// This must happen before getInfoFromConfigFile() tries to load the PROJECT file.
+	if err := handleInputDirBeforeConfigLoad(); err != nil {
+		return nil, err
+	}
+
 	// Build the cmd tree.
 	if err := c.buildCmd(); err != nil {
 		c.cmd.RunE = errCmdFunc(err)
@@ -319,6 +326,99 @@ func patchProjectFileInMemoryIfNeeded(fs afero.Fs, path string) error {
 	return nil
 }
 
+// parseInputDirFromArgs extracts --input-dir from raw CLI args without depending on
+// Cobra flag registration. It supports both:
+//
+//	--input-dir=/path/to/project
+//	--input-dir /path/to/project
+func parseInputDirFromArgs(args []string) (string, bool) {
+	for i := range args {
+		arg := args[i]
+
+		if arg == "--input-dir" {
+			if i+1 >= len(args) {
+				// Flag needs an argument but none provided
+				return "", false
+			}
+			return args[i+1], true
+		}
+
+		if after, ok := strings.CutPrefix(arg, "--input-dir="); ok {
+			return after, true
+		}
+	}
+
+	return "", false
+}
+
+// isEditCommand checks if the command invocation is `kubebuilder edit`
+// by scanning os.Args. We simply check if "edit" appears as a non-flag argument.
+func isEditCommand(args []string) bool {
+	for _, arg := range args {
+		// Skip flags (anything starting with -)
+		if strings.HasPrefix(arg, "-") {
+			continue
+		}
+		// First non-flag argument is the subcommand
+		if arg == "edit" {
+			return true
+		}
+		// If we found a different subcommand, return false
+		return false
+	}
+	return false
+}
+
+// handleInputDirBeforeConfigLoad 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 handleInputDirBeforeConfigLoad() error {
+	// Only process --input-dir for edit command
+	if !isEditCommand(os.Args[1:]) {
+		return nil
+	}
+
+	inputDir, found := parseInputDirFromArgs(os.Args[1:])
+	if !found || inputDir == "" {
+		return nil
+	}
+
+	// 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
+}
+
 // getInfoFromConfig obtains the project version and plugin keys from the project config.
 // It is extracted from getInfoFromConfigFile for testing purposes.
 func (c *CLI) getInfoFromConfig(projectConfig config.Config) error {

pkg/cli/cli_test.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"strings"
 
 	. "github.com/onsi/ginkgo/v2"
@@ -807,4 +808,214 @@ plugins:
 			})
 		})
 	})
+
+	Context("parseInputDirFromArgs", func() {
+		It("should return empty when flag is not present", func() {
+			args := []string{"edit", "--plugins=helm.kubebuilder.io/v2-alpha"}
+			dir, found := parseInputDirFromArgs(args)
+			Expect(found).To(BeFalse())
+			Expect(dir).To(BeEmpty())
+		})
+
+		It("should parse --input-dir with = syntax", func() {
+			args := []string{"edit", "--input-dir=/path/to/project", "--plugins=helm.kubebuilder.io/v2-alpha"}
+			dir, found := parseInputDirFromArgs(args)
+			Expect(found).To(BeTrue())
+			Expect(dir).To(Equal("/path/to/project"))
+		})
+
+		It("should parse --input-dir with space syntax", func() {
+			args := []string{"edit", "--input-dir", "/path/to/project", "--plugins=helm.kubebuilder.io/v2-alpha"}
+			dir, found := parseInputDirFromArgs(args)
+			Expect(found).To(BeTrue())
+			Expect(dir).To(Equal("/path/to/project"))
+		})
+
+		It("should return false when --input-dir has no value", func() {
+			args := []string{"edit", "--input-dir"}
+			dir, found := parseInputDirFromArgs(args)
+			Expect(found).To(BeFalse())
+			Expect(dir).To(BeEmpty())
+		})
+	})
+
+	Context("isEditCommand", func() {
+		It("should return true for edit command", func() {
+			args := []string{"edit", "--plugins=helm.kubebuilder.io/v2-alpha"}
+			Expect(isEditCommand(args)).To(BeTrue())
+		})
+
+		It("should return true for edit command with flags before", func() {
+			args := []string{"--verbose", "edit", "--plugins=helm.kubebuilder.io/v2-alpha"}
+			Expect(isEditCommand(args)).To(BeTrue())
+		})
+
+		It("should return false for init command", func() {
+			args := []string{"init", "--plugins=go.kubebuilder.io/v4"}
+			Expect(isEditCommand(args)).To(BeFalse())
+		})
+
+		It("should return false for create command", func() {
+			args := []string{"create", "api"}
+			Expect(isEditCommand(args)).To(BeFalse())
+		})
+	})
+
+	Context("handleInputDirBeforeConfigLoad integration", func() {
+		var (
+			originalArgs []string
+			originalDir  string
+			tmpDir       string
+		)
+
+		BeforeEach(func() {
+			// Save original os.Args and working directory
+			originalArgs = os.Args
+			var err error
+			originalDir, err = os.Getwd()
+			Expect(err).NotTo(HaveOccurred())
+
+			// Create temp directory for testing
+			tmpDir, err = os.MkdirTemp("", "input-dir-integration-*")
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		AfterEach(func() {
+			// Restore original state
+			os.Args = originalArgs
+			if originalDir != "" {
+				_ = os.Chdir(originalDir)
+			}
+			if tmpDir != "" {
+				_ = os.RemoveAll(tmpDir)
+			}
+		})
+
+		It("should do nothing when not an edit command", func() {
+			os.Args = []string{"kubebuilder", "init", "--plugins=go.kubebuilder.io/v4"}
+			err := handleInputDirBeforeConfigLoad()
+			Expect(err).NotTo(HaveOccurred())
+
+			// Working directory should not have changed
+			currentDir, err := os.Getwd()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(currentDir).To(Equal(originalDir))
+		})
+
+		It("should do nothing when input-dir is not specified", func() {
+			os.Args = []string{"kubebuilder", "edit", "--plugins=helm.kubebuilder.io/v2-alpha"}
+			err := handleInputDirBeforeConfigLoad()
+			Expect(err).NotTo(HaveOccurred())
+
+			// Working directory should not have changed
+			currentDir, err := os.Getwd()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(currentDir).To(Equal(originalDir))
+		})
+
+		It("should return error when input-dir does not exist", func() {
+			os.Args = []string{"kubebuilder", "edit", "--input-dir=/nonexistent/path"}
+			err := handleInputDirBeforeConfigLoad()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("does not exist"))
+		})
+
+		It("should return error when input-dir 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())
+
+			os.Args = []string{"kubebuilder", "edit", "--input-dir=" + filePath}
+			err = handleInputDirBeforeConfigLoad()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("not a directory"))
+		})
+
+		It("should return error when input-dir does not contain PROJECT file", func() {
+			// Create empty directory
+			emptyDir := filepath.Join(tmpDir, "empty")
+			err := os.MkdirAll(emptyDir, 0o755)
+			Expect(err).NotTo(HaveOccurred())
+
+			os.Args = []string{"kubebuilder", "edit", "--input-dir=" + emptyDir}
+			err = handleInputDirBeforeConfigLoad()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("does not contain"))
+			Expect(err.Error()).To(ContainSubstring("PROJECT"))
+		})
+
+		It("should change directory when valid input-dir is provided", func() {
+			// Create project directory with PROJECT file
+			projectDir := filepath.Join(tmpDir, "project")
+			err := os.MkdirAll(projectDir, 0o755)
+			Expect(err).NotTo(HaveOccurred())
+
+			projectFile := filepath.Join(projectDir, "PROJECT")
+			projectContent := `domain: example.com
+layout:
+- go.kubebuilder.io/v4
+- helm.kubebuilder.io/v2-alpha
+projectName: test-project
+repo: example.com/test-project
+version: "3"
+`
+			err = os.WriteFile(projectFile, []byte(projectContent), 0o644)
+			Expect(err).NotTo(HaveOccurred())
+
+			os.Args = []string{"kubebuilder", "edit", "--input-dir=" + projectDir}
+			err = handleInputDirBeforeConfigLoad()
+			Expect(err).NotTo(HaveOccurred())
+
+			// Verify directory changed
+			currentDir, err := os.Getwd()
+			Expect(err).NotTo(HaveOccurred())
+
+			// Resolve symlinks for comparison
+			expectedDir, err := filepath.EvalSymlinks(projectDir)
+			Expect(err).NotTo(HaveOccurred())
+			actualDir, err := filepath.EvalSymlinks(currentDir)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(actualDir).To(Equal(expectedDir))
+		})
+
+		It("should handle relative paths correctly", func() {
+			// Create project directory with PROJECT file
+			projectDir := filepath.Join(tmpDir, "project")
+			err := os.MkdirAll(projectDir, 0o755)
+			Expect(err).NotTo(HaveOccurred())
+
+			projectFile := filepath.Join(projectDir, "PROJECT")
+			projectContent := `domain: example.com
+layout:
+- go.kubebuilder.io/v4
+projectName: test-project
+repo: example.com/test-project
+version: "3"
+`
+			err = os.WriteFile(projectFile, []byte(projectContent), 0o644)
+			Expect(err).NotTo(HaveOccurred())
+
+			// Change to tmpDir and use relative path
+			err = os.Chdir(tmpDir)
+			Expect(err).NotTo(HaveOccurred())
+
+			os.Args = []string{"kubebuilder", "edit", "--input-dir=./project"}
+			err = handleInputDirBeforeConfigLoad()
+			Expect(err).NotTo(HaveOccurred())
+
+			// Verify directory changed
+			currentDir, err := os.Getwd()
+			Expect(err).NotTo(HaveOccurred())
+
+			// Resolve symlinks for comparison
+			expectedDir, err := filepath.EvalSymlinks(projectDir)
+			Expect(err).NotTo(HaveOccurred())
+			actualDir, err := filepath.EvalSymlinks(currentDir)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(actualDir).To(Equal(expectedDir))
+		})
+	})
 })

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
 }