replaced env vars with template field

Author: Padraic-O-Mhuiris

cmd/obol/network.go

@@ -74,75 +74,75 @@ func buildNetworkInstallCommands(cfg *config.Config) []*cli.Command {
 
 	var commands []*cli.Command
 	for _, networkName := range networks {
-		// Parse the embedded helmfile to get env vars
-		envVars, err := network.ParseEmbeddedNetworkEnvVars(networkName)
+		// Parse the embedded values template to get fields
+		fields, err := network.ParseTemplateFields(networkName)
 		if err != nil {
 			// Skip networks we can't parse
 			continue
 		}
 
-		// Build flags from env vars
+		// Build flags from template fields
 		flags := []cli.Flag{}
-		for _, envVar := range envVars {
+		for _, field := range fields {
 			// Customize id flag description to include network-specific example
-			if envVar.FlagName == "id" {
+			if field.FlagName == "id" {
 				flags = append(flags, &cli.StringFlag{
 					Name:     "id",
 					Usage:    fmt.Sprintf("Namespace suffix for this deployment (e.g., 'smart-kodiak' becomes '%s-smart-kodiak', defaults to generated petname)", networkName),
-					Required: envVar.Required,
+					Required: field.Required,
 				})
 				continue
 			}
 			// Build usage string
-			usage := envVar.Description
+			usage := field.Description
 			if usage == "" {
-				usage = fmt.Sprintf("Override %s", envVar.Name)
+				usage = fmt.Sprintf("Override %s", field.Name)
 			}
 
 			// Mark as required if no default value
-			if envVar.Required {
+			if field.Required {
 				usage = "[REQUIRED] " + usage
 			}
 
 			// Add enum options if available
-			if len(envVar.EnumValues) > 0 {
-				usage += fmt.Sprintf(" [options: %s]", strings.Join(envVar.EnumValues, ", "))
+			if len(field.EnumValues) > 0 {
+				usage += fmt.Sprintf(" [options: %s]", strings.Join(field.EnumValues, ", "))
 			}
 
 			// Add default value
-			if envVar.DefaultValue != "" {
-				usage += fmt.Sprintf(" (default: %s)", envVar.DefaultValue)
+			if field.DefaultValue != "" {
+				usage += fmt.Sprintf(" (default: %s)", field.DefaultValue)
 			}
 
 			flags = append(flags, &cli.StringFlag{
-				Name:     envVar.FlagName,
+				Name:     field.FlagName,
 				Usage:    usage,
-				Required: envVar.Required,
+				Required: field.Required,
 			})
 		}
 
 		// Create the network-specific install command
 		netName := networkName // Capture for closure
-		netEnvVars := envVars  // Capture for validation
+		netFields := fields    // Capture for validation
 		commands = append(commands, &cli.Command{
 			Name:  netName,
 			Usage: fmt.Sprintf("Install %s network", netName),
 			Flags: flags,
 			Action: func(c *cli.Context) error {
 				// Collect and validate flag values
 				overrides := make(map[string]string)
-				for _, envVar := range netEnvVars {
-					value := c.String(envVar.FlagName)
+				for _, field := range netFields {
+					value := c.String(field.FlagName)
 					if value != "" {
 						// Validate enum constraint if defined
-						if len(envVar.EnumValues) > 0 {
-							valid := slices.Contains(envVar.EnumValues, value)
+						if len(field.EnumValues) > 0 {
+							valid := slices.Contains(field.EnumValues, value)
 							if !valid {
 								return fmt.Errorf("invalid value '%s' for --%s. Valid options: %s",
-									value, envVar.FlagName, strings.Join(envVar.EnumValues, ", "))
+									value, field.FlagName, strings.Join(field.EnumValues, ", "))
 							}
 						}
-						overrides[envVar.FlagName] = value
+						overrides[field.FlagName] = value
 					}
 				}
 

internal/network/network.go

@@ -51,35 +51,35 @@ func Install(cfg *config.Config, network string, overrides map[string]string) er
 		fmt.Printf("Generated deployment ID: %s\n", id)
 	}
 
-	// Parse embedded helmfile to get template fields
-	envVars, err := ParseEmbeddedNetworkEnvVars(network)
+	// Parse embedded values template to get fields
+	fields, err := ParseTemplateFields(network)
 	if err != nil {
-		return fmt.Errorf("failed to parse embedded helmfile: %w", err)
+		return fmt.Errorf("failed to parse embedded values template: %w", err)
 	}
 
 	// Build template data from CLI flags and defaults
 	templateData := make(map[string]string)
-	if len(envVars) > 0 {
+	if len(fields) > 0 {
 		fmt.Println("Configuration:")
-		for _, envVar := range envVars {
-			value := envVar.DefaultValue
+		for _, field := range fields {
+			value := field.DefaultValue
 
 			// Check if there's an override from CLI flags
-			if overrideValue, ok := overrides[envVar.FlagName]; ok {
+			if overrideValue, ok := overrides[field.FlagName]; ok {
 				value = overrideValue
-				fmt.Printf("  %s = %s (from --%s)\n", envVar.Name, value, envVar.FlagName)
-			} else if envVar.Required && value == "" {
+				fmt.Printf("  %s = %s (from --%s)\n", field.Name, value, field.FlagName)
+			} else if field.Required && value == "" {
 				// Required field with no value provided
-				return fmt.Errorf("missing required flag: --%s", envVar.FlagName)
+				return fmt.Errorf("missing required flag: --%s", field.FlagName)
 			} else if value != "" {
-				fmt.Printf("  %s = %s (default)\n", envVar.Name, value)
+				fmt.Printf("  %s = %s (default)\n", field.Name, value)
 			} else {
 				// Optional field with empty default
-				fmt.Printf("  %s = (empty, optional)\n", envVar.Name)
+				fmt.Printf("  %s = (empty, optional)\n", field.Name)
 			}
 
 			// Add to template data using field name (e.g., "Network", "ExecutionClient")
-			templateData[envVar.Name] = value
+			templateData[field.Name] = value
 		}
 	}
 

internal/network/parser.go

@@ -10,14 +10,14 @@ import (
 	"github.com/ObolNetwork/obol-stack/internal/embed"
 )
 
-// EnvVar represents an environment variable with its default value
-type EnvVar struct {
+// TemplateField represents a template field with its configuration
+type TemplateField struct {
 	Name         string
 	DefaultValue string
-	FlagName     string   // CLI flag name derived from env var name
+	FlagName     string   // CLI flag name derived from field name
 	Description  string   // Human-readable description from @description
 	EnumValues   []string // Valid enum values from @enum
-	Required     bool     // Whether this env var is required (no default value)
+	Required     bool     // Whether this field is required (no default value)
 }
 
 // extractTemplateFields parses a Go template and extracts all field references
@@ -130,26 +130,26 @@ func parseAnnotationsFromLines(lines []string, fieldLineNum int) ([]string, stri
 	return enumValues, defaultValue, description, hasDefault
 }
 
-// ParseEmbeddedNetworkEnvVars extracts template fields from an embedded network values file
-// Now uses Go template parsing instead of regex-based env var detection
-func ParseEmbeddedNetworkEnvVars(networkName string) ([]EnvVar, error) {
+// ParseTemplateFields extracts template fields from an embedded network values file
+// Uses Go template parsing to identify field references and their annotations
+func ParseTemplateFields(networkName string) ([]TemplateField, error) {
 	// Read the embedded values template
 	content, err := embed.ReadEmbeddedNetworkFile(networkName, "values.yaml.gotmpl")
 	if err != nil {
 		return nil, fmt.Errorf("failed to read embedded values: %w", err)
 	}
 
 	// Extract template fields using Go template parser
-	fields, err := extractTemplateFields(string(content))
+	fieldMap, err := extractTemplateFields(string(content))
 	if err != nil {
 		return nil, fmt.Errorf("failed to extract template fields: %w", err)
 	}
 
 	lines := strings.Split(string(content), "\n")
-	var envVars []EnvVar
+	var fields []TemplateField
 
-	// For each field, extract annotations and create EnvVar
-	for fieldName, lineNum := range fields {
+	// For each field, extract annotations and create TemplateField
+	for fieldName, lineNum := range fieldMap {
 		enumValues, defaultValue, description, hasDefault := parseAnnotationsFromLines(lines, lineNum)
 
 		// Convert field name to CLI flag name (e.g., ExecutionClient -> execution-client)
@@ -158,18 +158,18 @@ func ParseEmbeddedNetworkEnvVars(networkName string) ([]EnvVar, error) {
 		// Determine if field is required (no @default annotation)
 		required := !hasDefault
 
-		envVar := EnvVar{
+		field := TemplateField{
 			Name:         fieldName,
 			DefaultValue: defaultValue,
 			FlagName:     flagName,
 			Description:  description,
 			EnumValues:   enumValues,
 			Required:     required,
 		}
-		envVars = append(envVars, envVar)
+		fields = append(fields, field)
 	}
 
-	return envVars, nil
+	return fields, nil
 }
 
 // fieldNameToFlagName converts a template field name to a CLI flag name