chore(helm/v2-alpha): add --input-dir flag for flexible project path resolution

Add --input-dir flag to the helm v2-alpha plugin to align with the
alpha generate command pattern. This provides a consistent user
experience across commands and makes the plugin more flexible.

Changes:
- Add --input-dir flag to specify the directory containing PROJECT file and manifests
- Resolve manifests path relative to input-dir when not absolute
- Add documentation and examples for the new flag

Co-Authored-By: porridge@redhat.com
Assisted-by: Claude

Author: camilamacedo86

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

@@ -74,6 +74,8 @@ kubebuilder edit --plugins=helm/v2-alpha \
   --output-dir=helm-charts
 ```
 
+**Note**: The `--input-dir` flag sets the base directory for resolving relative paths and running make commands. The CLI currently loads the `PROJECT` file from the current working directory before the plugin runs, so you must still run `kubebuilder edit` from the project root.
+
 ## Chart Structure
 
 The plugin creates a chart layout that matches your `config/`:
@@ -353,9 +355,10 @@ 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`)                                |
-| **--force**         | Regenerates preserved files except `Chart.yaml` (`values.yaml`, `NOTES.txt`, `_helpers.tpl`, `.helmignore`, `test-chart.yml`) |
+| **--input-dir**     | Base directory for resolving relative paths and running make commands. Defaults to current directory. Note: The `PROJECT` file is loaded from the current working directory by the CLI framework. |
+| **--manifests**     | Path to YAML file containing Kubernetes manifests from kustomize output. Default: `dist/install.yaml`. If not absolute, resolved relative to `--input-dir`. |
+| **--output-dir**    | Output directory for the generated Helm chart. Default: `dist`. If not absolute, resolved relative to `--input-dir`. |
+| **--force**         | If true, regenerates all preserved files except `Chart.yaml` (includes `values.yaml`, `NOTES.txt`, `_helpers.tpl`, `.helmignore`, `test-chart.yml`). |
 
 <aside class="note" role="note">
 <p class="note-title"> Examples </p>

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

@@ -22,6 +22,7 @@ import (
 	"io"
 	"log/slog"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -50,6 +51,7 @@ var _ plugin.EditSubcommand = &editSubcommand{}
 type editSubcommand struct {
 	config        config.Config
 	force         bool
+	inputDir      string
 	manifestsFile string
 	outputDir     string
 }
@@ -103,8 +105,11 @@ The generated chart structure mirrors your config/ directory:
 
 func (p *editSubcommand) BindFlags(fs *pflag.FlagSet) {
 	fs.BoolVar(&p.force, "force", false, "if true, regenerates all the files")
+	fs.StringVar(&p.inputDir, "input-dir", "",
+		"base directory for resolving relative paths and running make commands (defaults to current directory)")
 	fs.StringVar(&p.manifestsFile, "manifests", DefaultManifestsFile,
-		"path to the YAML file containing Kubernetes manifests from kustomize output")
+		"path to the YAML file containing Kubernetes manifests from kustomize output "+
+			"(resolved relative to input-dir if not absolute)")
 	fs.StringVar(&p.outputDir, "output-dir", DefaultOutputDir, "output directory for the generated Helm chart")
 }
 
@@ -114,14 +119,44 @@ func (p *editSubcommand) InjectConfig(c config.Config) error {
 }
 
 func (p *editSubcommand) Scaffold(fs machinery.Filesystem) error {
+	// Set input directory to current working directory if not specified
+	if p.inputDir == "" {
+		cwd, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("failed to get current working directory: %w", err)
+		}
+		p.inputDir = cwd
+	}
+
+	// Ensure input directory is an absolute path
+	if !filepath.IsAbs(p.inputDir) {
+		absInputDir, err := filepath.Abs(p.inputDir)
+		if err != nil {
+			return fmt.Errorf("failed to resolve input directory %q: %w", p.inputDir, err)
+		}
+		p.inputDir = absInputDir
+	}
+
+	// Resolve manifests path relative to input directory when not absolute
+	manifestsPath := p.manifestsFile
+	if !filepath.IsAbs(manifestsPath) {
+		manifestsPath = filepath.Join(p.inputDir, manifestsPath)
+	}
+
+	// Resolve output directory relative to input directory when not absolute
+	outputDir := p.outputDir
+	if !filepath.IsAbs(outputDir) {
+		outputDir = filepath.Join(p.inputDir, outputDir)
+	}
+
 	// If using default manifests file, ensure it exists by running make build-installer
 	if p.manifestsFile == DefaultManifestsFile {
-		if err := p.ensureManifestsExist(); err != nil {
-			slog.Warn("Failed to generate default manifests file", "error", err, "file", p.manifestsFile)
+		if err := p.ensureManifestsExist(manifestsPath); err != nil {
+			slog.Warn("Failed to generate default manifests file", "error", err, "file", manifestsPath)
 		}
 	}
 
-	scaffolder := scaffolds.NewKustomizeHelmScaffolder(p.config, p.force, p.manifestsFile, p.outputDir)
+	scaffolder := scaffolds.NewKustomizeHelmScaffolder(p.config, p.force, manifestsPath, outputDir)
 	scaffolder.InjectFS(fs)
 	err := scaffolder.Scaffold()
 	if err != nil {
@@ -175,7 +210,7 @@ func (p *editSubcommand) Scaffold(fs machinery.Filesystem) error {
 	if isFirstRun {
 		slog.Info("adding Helm deployment targets to Makefile...")
 		// Extract namespace from manifests for accurate Makefile generation
-		namespace := p.extractNamespaceFromManifests()
+		namespace := p.extractNamespaceFromManifests(manifestsPath)
 		if err := p.addHelmMakefileTargets(namespace); err != nil {
 			slog.Warn("failed to add Helm targets to Makefile", "error", err)
 		}
@@ -184,33 +219,52 @@ func (p *editSubcommand) Scaffold(fs machinery.Filesystem) error {
 	return nil
 }
 
-// ensureManifestsExist runs make build-installer to generate the default manifests file
-func (p *editSubcommand) ensureManifestsExist() error {
-	slog.Info("Generating default manifests file", "file", p.manifestsFile)
+// ensureManifestsExist runs make build-installer to generate the default manifests file.
+func (p *editSubcommand) ensureManifestsExist(manifestsPath string) error {
+	slog.Info("Generating default manifests file", "file", manifestsPath)
 
-	// Run the required make targets to generate the manifests file
+	// Run required make targets to generate the manifests file
 	targets := []string{"manifests", "generate", "build-installer"}
 	for _, target := range targets {
-		if err := util.RunCmd(fmt.Sprintf("Running make %s", target), "make", target); err != nil {
+		if err := p.runMakeTarget(target); err != nil {
 			return fmt.Errorf("make %s failed: %w", target, err)
 		}
 	}
 
 	// Verify the file was created
-	if _, err := os.Stat(p.manifestsFile); err != nil {
-		return fmt.Errorf("manifests file %s was not created: %w", p.manifestsFile, err)
+	if _, err := os.Stat(manifestsPath); err != nil {
+		return fmt.Errorf("manifests file %s was not created: %w", manifestsPath, err)
 	}
 
-	slog.Info("Successfully generated manifests file", "file", p.manifestsFile)
+	slog.Info("Successfully generated manifests file", "file", manifestsPath)
 	return nil
 }
 
-// PostScaffold automatically uncomments cert-manager installation when webhooks are present
+// runMakeTarget executes a make target in the input directory.
+func (p *editSubcommand) runMakeTarget(target string) error {
+	cmd := exec.Command("make", target)
+	cmd.Dir = p.inputDir
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	slog.Info(fmt.Sprintf("Running make %s", target), "dir", p.inputDir)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("error running make %s: %w", target, err)
+	}
+	return nil
+}
+
+// PostScaffold automatically uncomments cert-manager installation when webhooks are present.
 func (p *editSubcommand) PostScaffold() error {
 	hasWebhooks := hasWebhooksWith(p.config)
 
 	if hasWebhooks {
-		workflowFile := filepath.Join(".github", "workflows", "test-chart.yml")
+		// The scaffolder creates the workflow file relative to CWD (via machinery.Filesystem),
+		// not relative to inputDir, so we look for it in CWD
+		baseDir, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("failed to get current directory: %w", err)
+		}
+		workflowFile := filepath.Join(baseDir, ".github", "workflows", "test-chart.yml")
 		if _, err := os.Stat(workflowFile); err != nil {
 			slog.Info(
 				"Workflow file not found, unable to uncomment cert-manager installation",
@@ -243,14 +297,14 @@ func (p *editSubcommand) PostScaffold() error {
 	return nil
 }
 
-// addHelmMakefileTargets appends Helm deployment targets to the Makefile if they don't already exist
+// addHelmMakefileTargets appends Helm deployment targets to the Makefile if they don't already exist.
 func (p *editSubcommand) addHelmMakefileTargets(namespace string) error {
-	makefilePath := "Makefile"
+	makefilePath := filepath.Join(p.inputDir, "Makefile")
 	if _, err := os.Stat(makefilePath); os.IsNotExist(err) {
-		return fmt.Errorf("makefile not found")
+		return fmt.Errorf("makefile not found at %q", makefilePath)
 	}
 
-	// Get the Helm Makefile targets
+	// Use original outputDir value (not absolute path) for Makefile variables
 	helmTargets := getHelmMakefileTargets(p.config.GetProjectName(), namespace, p.outputDir)
 
 	// Append the targets if they don't already exist
@@ -265,17 +319,17 @@ func (p *editSubcommand) addHelmMakefileTargets(namespace string) error {
 
 // extractNamespaceFromManifests parses the manifests file to extract the manager namespace.
 // Returns projectName-system if manifests don't exist or namespace not found.
-func (p *editSubcommand) extractNamespaceFromManifests() string {
+func (p *editSubcommand) extractNamespaceFromManifests(manifestsPath string) string {
 	// Default to project-name-system pattern
 	defaultNamespace := p.config.GetProjectName() + "-system"
 
 	// If manifests file doesn't exist, use default
-	if _, err := os.Stat(p.manifestsFile); os.IsNotExist(err) {
+	if _, err := os.Stat(manifestsPath); os.IsNotExist(err) {
 		return defaultNamespace
 	}
 
 	// Parse the manifests to get the namespace
-	file, err := os.Open(p.manifestsFile)
+	file, err := os.Open(manifestsPath)
 	if err != nil {
 		return defaultNamespace
 	}
@@ -312,8 +366,8 @@ func (p *editSubcommand) extractNamespaceFromManifests() string {
 	return defaultNamespace
 }
 
-// getHelmMakefileTargets returns the Helm Makefile targets as a string
-// following the same patterns as the existing Makefile deployment section
+// getHelmMakefileTargets returns the Helm Makefile targets as a string.
+// It follows the same patterns as the existing Makefile deployment section.
 func getHelmMakefileTargets(projectName, namespace, outputDir string) string {
 	if outputDir == "" {
 		outputDir = "dist"
@@ -325,8 +379,8 @@ func getHelmMakefileTargets(projectName, namespace, outputDir string) string {
 	return helmMakefileTemplate(namespace, release, outputDir)
 }
 
-// helmMakefileTemplate returns the Helm deployment section template
-// This follows the same pattern as the Kustomize deployment section in the Go plugin
+// helmMakefileTemplate returns the Helm deployment section template.
+// It follows the same pattern as the Kustomize deployment section in the Go plugin.
 const helmMakefileTemplateFormat = `
 ##@ Helm Deployment