Implement Task 3.7: Add interactive values init command and update validation for single environment

ritwik-g · claude · ritwik-g · commit 9f1edc394771 · 2025-06-14T16:01:30.000+05:30
### Task 3.7: Interactive Environment Setup - Added 'values init --env <env>' command for interactive value setup - Supports required-first ordering with optional fields after - Interactive prompts for each unset value with type validation - Extensible secret configuration with environment variable support - Skip individual fields or skip all remaining fields - Force mode to use defaults where possible - Comprehensive error handling and user feedback - Shows summary of set/skipped values and warnings for unset required fields ### Validation Updates - Made --env parameter required for validate command (single environment focus) - Updated validator to work with flat file structure (no environment key nesting) - Removed multi-environment validation (one environment per command execution) - Updated all tests to match single-environment approach - Fixed environment name display in validation errors ### Architecture Consistency - All commands now work with single environment per execution - Values files use flat structure (no environment key nesting) - Consistent --env parameter across all commands - Simplified file format reduces confusion 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/guide/prompt_plan.md b/guide/prompt_plan.md
@@ -147,13 +147,36 @@ Update both `values set` and `values set-secret` commands to:
    c. Abort if not confirmed
 3. For `values set-secret`:
    a. Show both current type and name if available
-   b. Example prompt: 
+   b. Example prompt:
         "Key 'database-password' already set as env:PROD_DB_PASSWORD
          Overwrite? [y/N]"
 4. Add --force flag to bypass confirmation
 ```
 **Status**: Completed - Confirmation prompts with --force flag bypass
 
+#### Task 3.7: Interactive Environment Setup ✅
+```prompt
+Implement `values init --env <env>` command that:
+1. Loads schema and checks for unset values in specified environment
+2. For each unset value (required first, then optional):
+   a. Show key, description, type, and required status
+   b. Prompt: "Set value for [key]? (Y/n/skip)"
+      - Y: Proceed to value input (normal/sensitive based on schema)
+      - n: Skip this field
+      - skip: Skip all remaining
+3. For sensitive values:
+   a. Use `set-secret` workflow (with type selection)
+4. For non-sensitive values:
+   a. Show current default (if exists)
+   b. Prompt for value with type validation
+5. After all fields:
+   a. Show summary:
+        "Set X values, skipped Y required values"
+   b. List any unset required values
+6. Add --force to disable prompts (use defaults where possible)
+```
+**Status**: Completed - Interactive setup with type validation and extensible secret support
+
 ### Phase 4: Core Engine
 #### Task 4.1: Validator ✅
 ```prompt
diff --git a/helm_values_manager/commands/validate.py b/helm_values_manager/commands/validate.py
@@ -10,6 +10,7 @@
 
 
 def validate_command(
+    env: str = typer.Option(..., "--env", "-e", help="Environment to validate"),
     schema: str = typer.Option(
         "schema.json",
         "--schema",
@@ -19,24 +20,17 @@ def validate_command(
     values: Optional[str] = typer.Option(
         None,
         "--values",
-        help="Base path for values files (directory containing values-{env}.json files)",
-    ),
-    env: Optional[str] = typer.Option(
-        None,
-        "--env",
-        "-e",
-        help="Validate specific environment only",
+        help="Path to values file (default: values-{env}.json)",
     ),
 ):
-    """Validate schema and values files."""
+    """Validate schema and values file for a specific environment."""
     # Import here to avoid circular imports
-    from helm_values_manager.validator import validate_command as run_validation
+    from helm_values_manager.validator import validate_single_environment
     
     schema_path = Path(schema)
-    values_base_path = Path(values) if values else Path(".")
     
-    # Run validation
-    success = run_validation(schema_path, values_base_path, env)
+    # Run validation for single environment
+    success = validate_single_environment(schema_path, env, values)
     
     if not success:
         raise typer.Exit(code=1)
diff --git a/helm_values_manager/commands/values.py b/helm_values_manager/commands/values.py
@@ -275,4 +275,158 @@ def remove_command(
     # Save values
     save_values(values, env, values_path)
     
-    console.print(f"[green]✓[/green] Removed '{key}' from environment '{env}'")
+    console.print(f"[green]✓[/green] Removed '{key}' from environment '{env}'")
+
+
+@app.command("init")
+def init_command(
+    env: str = typer.Option(..., "--env", "-e", help="Environment name"),
+    schema_path: str = typer.Option("schema.json", "--schema", "-s", help="Path to schema file"),
+    values_path: Optional[str] = typer.Option(None, "--values", help="Path to values file"),
+    force: bool = typer.Option(False, "--force", "-f", help="Use defaults where possible, skip prompts"),
+):
+    """Interactively set up values for an environment."""
+    # Load schema
+    schema = load_schema(schema_path)
+    if not schema:
+        console.print("[red]Error:[/red] Schema file not found")
+        raise typer.Exit(1)
+    
+    # Load existing values
+    values = load_values(env, values_path)
+    
+    # Track statistics
+    set_count = 0
+    skipped_count = 0
+    skipped_required = []
+    
+    # Sort values: required first, then by key
+    sorted_values = sorted(schema.values, key=lambda v: (not v.required, v.key))
+    
+    console.print(f"\n[bold]Setting up values for environment: {env}[/bold]\n")
+    
+    skip_all = False
+    
+    for schema_value in sorted_values:
+        # Skip if already set
+        if schema_value.key in values:
+            continue
+        
+        # Skip if user chose to skip all
+        if skip_all:
+            skipped_count += 1
+            if schema_value.required:
+                skipped_required.append(schema_value.key)
+            continue
+        
+        # Display field info
+        console.print(f"\n[bold cyan]{schema_value.key}[/bold cyan]")
+        console.print(f"  Description: {schema_value.description}")
+        console.print(f"  Type: {schema_value.type}")
+        console.print(f"  Required: {'Yes' if schema_value.required else 'No'}")
+        if schema_value.default is not None:
+            console.print(f"  Default: {schema_value.default}")
+        
+        # Prompt for action
+        if force:
+            # In force mode, use defaults where possible
+            if schema_value.default is not None:
+                values[schema_value.key] = schema_value.default
+                set_count += 1
+                console.print(f"  → Using default value: {schema_value.default}")
+                continue
+            elif schema_value.required:
+                # Can't skip required values without defaults in force mode
+                console.print(f"  → [yellow]Warning: Required field with no default, skipping[/yellow]")
+                skipped_count += 1
+                skipped_required.append(schema_value.key)
+                continue
+            else:
+                # Skip optional fields without defaults
+                skipped_count += 1
+                continue
+        
+        # Interactive mode
+        action = Prompt.ask(
+            f"\nSet value for '{schema_value.key}'?",
+            choices=["y", "n", "skip"],
+            default="y"
+        )
+        
+        if action == "skip":
+            skip_all = True
+            skipped_count += 1
+            if schema_value.required:
+                skipped_required.append(schema_value.key)
+            continue
+        elif action == "n":
+            skipped_count += 1
+            if schema_value.required:
+                skipped_required.append(schema_value.key)
+            continue
+        
+        # Set the value
+        if schema_value.sensitive:
+            # Use set-secret workflow
+            console.print("\n[yellow]This is a sensitive value. Setting up as secret...[/yellow]")
+            
+            # Display secret type options
+            console.print("  1. Environment variable")
+            console.print("  [dim]2. HashiCorp Vault (coming soon)[/dim]")
+            console.print("  [dim]3. AWS Secrets Manager (coming soon)[/dim]")
+            console.print("  [dim]4. Azure Key Vault (coming soon)[/dim]")
+            
+            # Select secret type
+            secret_type = Prompt.ask(
+                "Select secret type",
+                choices=["1"],
+                default="1"
+            )
+            
+            if secret_type == "1":
+                env_var_name = Prompt.ask("Environment variable name")
+                
+                # Check if environment variable exists
+                if not os.environ.get(env_var_name):
+                    console.print(f"[yellow]⚠ Warning: Environment variable '{env_var_name}' is not set[/yellow]")
+                
+                values[schema_value.key] = {
+                    "type": "env",
+                    "name": env_var_name
+                }
+                set_count += 1
+        else:
+            # Regular value
+            if schema_value.default is not None:
+                prompt_text = f"Value (default: {schema_value.default})"
+                default_str = str(schema_value.default)
+            else:
+                prompt_text = "Value"
+                default_str = None
+            
+            while True:
+                value_str = Prompt.ask(prompt_text, default=default_str)
+                
+                try:
+                    parsed_value = parse_value_by_type(value_str, schema_value.type)
+                    values[schema_value.key] = parsed_value
+                    set_count += 1
+                    break
+                except (ValueError, json.JSONDecodeError, typer.BadParameter) as e:
+                    console.print(f"[red]Error:[/red] {e}")
+                    continue
+    
+    # Save values
+    save_values(values, env, values_path)
+    
+    # Show summary
+    console.print(f"\n[bold]Summary:[/bold]")
+    console.print(f"  Set {set_count} values")
+    console.print(f"  Skipped {skipped_count} values")
+    
+    if skipped_required:
+        console.print(f"\n[yellow]⚠ Warning: The following required values were not set:[/yellow]")
+        for key in skipped_required:
+            console.print(f"  - {key}")
+    
+    console.print(f"\n[green]✓[/green] Initialization complete for environment '{env}'")
diff --git a/helm_values_manager/validator.py b/helm_values_manager/validator.py
@@ -115,23 +115,24 @@ def _validate_schema(self):
                         ValidationError("Schema", f"Default value type mismatch for {entry.key}")
                     )
     
-    def _validate_values_for_env(self, env: str):
+    def _validate_values_for_env(self, env: str, values_file_path: Optional[str] = None):
         """Validate values for a specific environment."""
-        values_file = self.values_base_path / f"values-{env}.json"
+        if values_file_path:
+            values_file = Path(values_file_path)
+        else:
+            values_file = self.values_base_path / f"values-{env}.json"
         
         if not values_file.exists():
             # Not an error if no values file exists
             return
         
         try:
             with open(values_file) as f:
-                values = json.load(f)
+                env_values = json.load(f)
         except json.JSONDecodeError as e:
             self.errors.append(ValidationError("Values", f"Invalid JSON in {values_file}: {e}", env))
             return
         
-        env_values = values.get(env, {})
-        
         # Load schema
         try:
             if not self.schema_path.exists():
@@ -238,6 +239,28 @@ def print_errors(self):
             console.print(f"  - {str(error)}")
 
 
+def validate_single_environment(
+    schema_path: Path,
+    env: str,
+    values_file_path: Optional[str] = None
+) -> bool:
+    """Run validation for a single environment and report results."""
+    validator = Validator(schema_path, Path("."))
+    
+    # Validate schema first
+    validator._validate_schema()
+    
+    # Then validate values for the specific environment
+    validator._validate_values_for_env(env, values_file_path)
+    
+    if len(validator.errors) == 0:
+        console.print(f"✅ Validation passed for environment: {env}")
+        return True
+    else:
+        validator.print_errors()
+        return False
+
+
 def validate_command(
     schema_path: Path,
     values_base_path: Optional[Path] = None,
diff --git a/tests/test_validate.py b/tests/test_validate.py
diff --git a/tests/test_values_init.py b/tests/test_values_init.py
