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

@@ -72,6 +72,16 @@ kubebuilder edit --plugins=helm/v2-alpha --output-dir=charts
 kubebuilder edit --plugins=helm/v2-alpha \
   --manifests=manifests/install.yaml \
   --output-dir=helm-charts
+
+# Work with a project in a different directory
+# All relative paths (manifests, output-dir) are resolved relative to input-dir
+kubebuilder edit --plugins=helm/v2-alpha --input-dir=./path/to/project
+
+# Use custom manifests and output paths (both resolved relative to input-dir)
+kubebuilder edit --plugins=helm/v2-alpha \
+  --input-dir=./path/to/project \
+  --manifests=custom/install.yaml \
+  --output-dir=helm-charts
 ```
 
 ## Chart Structure
@@ -353,9 +363,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**     | Path to the project directory containing the PROJECT file. Defaults to current directory. All relative paths are resolved relative to this directory. |
+| **--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
 }
@@ -76,6 +78,12 @@ 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
 
+# Generate chart from a different project directory
+  %[1]s edit --plugins=%[2]s --input-dir=./path/to/project
+
+# Use custom manifests file (resolved relative to input-dir)
+  %[1]s edit --plugins=%[2]s --input-dir=./path/to/project --manifests=custom/install.yaml
+
 # 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/
@@ -103,8 +111,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", "",
+		"path to the directory containing the PROJECT file and manifests (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 +125,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 +216,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,24 +225,37 @@ 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
+}
+
+// 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
 }
 
@@ -210,7 +264,17 @@ func (p *editSubcommand) PostScaffold() error {
 	hasWebhooks := hasWebhooksWith(p.config)
 
 	if hasWebhooks {
-		workflowFile := filepath.Join(".github", "workflows", "test-chart.yml")
+		// Use input directory as base, or current directory if not set
+		// (inputDir may not be set when PostScaffold is called directly in tests)
+		baseDir := p.inputDir
+		if baseDir == "" {
+			var err error
+			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 +307,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 +329,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 +376,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 +389,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