Fix values init --force behavior and add --skip-defaults flag

**Problem:**
- `values init --force` was creating invalid configurations by skipping required fields without defaults
- No option to skip fields with defaults entirely

**Solution:**
1. **Fixed --force behavior:**
   - ✅ Use defaults automatically (no prompt)
   - ✅ Still prompt for required fields without defaults (ensures valid config)
   - ✅ Skip optional fields without defaults
   - ✅ Never create invalid configurations

2. **Added --skip-defaults flag:**
   - Skip all fields with default values entirely
   - Can be combined with --force for ultimate speed

**New Behaviors:**
```bash
# Normal: Full interactive
helm values-manager values init --env prod

# Fixed --force: Safe + fast
helm values-manager values init --env prod --force
# → Uses defaults, prompts only for required fields without defaults

# New --skip-defaults: Skip defaults entirely
helm values-manager values init --env prod --skip-defaults
# → Skip defaults, prompt for everything else

# Combined: Maximum speed
helm values-manager values init --env prod --force --skip-defaults
# → Skip defaults, use where needed, prompt only for required without defaults
```

**Testing:**
- Added comprehensive tests for all flag combinations
- Updated existing tests to expect new safe behavior
- All 121 tests passing with 81% coverage

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ritwik-g

guide/idea phase2.md

@@ -1,4 +1,11 @@
 - Support loading `.env` file for ENV based secrets
+- May be an option 2 specify schema path?
 - Support to add schemas without interaction.
-- value from multiple options
--
+- Updating schema or schema migration. Cases like default value change / path change / deletion etc.
+- value from multiple options (eg: value should be one of [a,b,c])
+- Nice to have: completion based on resources in json files.
+
+bugs
+- While using `helm-values-manager values init` or `helm-values-manager values set` what is the difference between n/skip both seems to do same functionality
+
+- `helm-values-manager values init -f` is only supposed to skip default value's prompt and ask others. But looks like it add the default values in to the values json file while not prompting others. Either -f should skip the defaults all together and ask about others. Or we should add new option to skip defaults. What do you think?

helm_values_manager/commands/values.py

@@ -275,7 +275,8 @@ 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"),
+    force: bool = typer.Option(False, "--force", "-f", help="Use defaults where possible, prompt only for required fields without defaults"),
+    skip_defaults: bool = typer.Option(False, "--skip-defaults", help="Skip fields with default values entirely"),
 ):
     """Interactively set up values for an environment."""
     # Load schema
@@ -318,31 +319,39 @@ def init_command(
         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"  → Required field with no default, skipping")
-                skipped_count += 1
-                skipped_required.append(schema_value.key)
-                continue
-            else:
-                # Skip optional fields without defaults
-                skipped_count += 1
-                continue
+        # Determine behavior based on flags
+        has_default = schema_value.default is not None
+        
+        # Handle skip-defaults flag
+        if skip_defaults and has_default:
+            skipped_count += 1
+            console.print(f"  → Skipping field with default value")
+            continue
 
-        # Interactive mode
-        action = Prompt.ask(
-            f"\nSet value for '{schema_value.key}'?",
-            choices=["y", "n", "skip"],
-            default="y"
-        )
+        # Handle force mode
+        if force and has_default:
+            # Use defaults automatically in force mode
+            values[schema_value.key] = schema_value.default
+            set_count += 1
+            console.print(f"  → Using default value: {schema_value.default}")
+            continue
+        elif force and not has_default and not schema_value.required:
+            # Skip optional fields without defaults in force mode
+            skipped_count += 1
+            console.print(f"  → Skipping optional field without default")
+            continue
+        elif force and not has_default and schema_value.required:
+            # Required fields without defaults must be prompted even in force mode
+            console.print(f"  → Required field with no default, prompting...")
+            # Skip the "Set value?" prompt and go directly to value input
+            action = "y"  # Force yes for required fields in force mode
+        else:
+            # Interactive mode - ask if user wants to set value
+            action = Prompt.ask(
+                f"\nSet value for '{schema_value.key}'?",
+                choices=["y", "n", "skip"],
+                default="y"
+            )
 
         if action == "skip":
             skip_all = True

tests/test_init_flags.py

@@ -0,0 +1,216 @@
+"""Tests for values init command flag behavior."""
+import json
+from pathlib import Path
+
+import pytest
+from typer.testing import CliRunner
+
+from helm_values_manager.cli import app
+
+runner = CliRunner()
+
+
+def test_force_mode_fixed_behavior(tmp_path):
+    """Test that --force mode prompts for required fields without defaults."""
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        # Create schema with mix of fields
+        schema_data = {
+            "version": "1.0",
+            "values": [
+                {
+                    "key": "app-name",
+                    "path": "app.name",
+                    "description": "Application name",
+                    "type": "string",
+                    "required": True,
+                    "default": "myapp"
+                },
+                {
+                    "key": "port",
+                    "path": "app.port",
+                    "description": "Application port",
+                    "type": "number",
+                    "required": True
+                    # No default - should be prompted even in force mode
+                },
+                {
+                    "key": "debug",
+                    "path": "app.debug",
+                    "description": "Debug mode",
+                    "type": "boolean",
+                    "required": False,
+                    "default": False
+                },
+                {
+                    "key": "features",
+                    "path": "app.features",
+                    "description": "Feature flags",
+                    "type": "array",
+                    "required": False
+                    # No default - should be skipped in force mode
+                }
+            ]
+        }
+        
+        with open("schema.json", "w") as f:
+            json.dump(schema_data, f, indent=2)
+        
+        # Test force mode with input for required field
+        result = runner.invoke(app, [
+            "values", "init", 
+            "--env", "test",
+            "--force"
+        ], input="8080\n")  # Input for port
+        
+        assert result.exit_code == 0
+        
+        # Check output messages
+        assert "Using default value: myapp" in result.output
+        assert "Using default value: False" in result.output
+        assert "Required field with no default, prompting" in result.output
+        assert "Skipping optional field without default" in result.output
+        
+        # Check generated values file
+        with open("values-test.json") as f:
+            values = json.load(f)
+        
+        expected_values = {
+            "app-name": "myapp",    # From default
+            "port": 8080,           # From user input
+            "debug": False          # From default
+            # features should not be present (skipped)
+        }
+        
+        assert values == expected_values
+
+
+def test_skip_defaults_mode(tmp_path):
+    """Test that --skip-defaults skips fields with defaults."""
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        # Create schema
+        schema_data = {
+            "version": "1.0",
+            "values": [
+                {
+                    "key": "app-name",
+                    "path": "app.name",
+                    "description": "Application name",
+                    "type": "string",
+                    "required": True,
+                    "default": "myapp"
+                },
+                {
+                    "key": "port",
+                    "path": "app.port",
+                    "description": "Application port",
+                    "type": "number",
+                    "required": True
+                },
+                {
+                    "key": "debug",
+                    "path": "app.debug",
+                    "description": "Debug mode",
+                    "type": "boolean",
+                    "required": False,
+                    "default": False
+                }
+            ]
+        }
+        
+        with open("schema.json", "w") as f:
+            json.dump(schema_data, f, indent=2)
+        
+        # Test skip-defaults mode
+        result = runner.invoke(app, [
+            "values", "init",
+            "--env", "test", 
+            "--skip-defaults"
+        ], input="y\n8080\n")  # y for port, 8080 as value
+        
+        assert result.exit_code == 0
+        
+        # Check output messages
+        assert "Skipping field with default value" in result.output
+        
+        # Check generated values file
+        with open("values-test.json") as f:
+            values = json.load(f)
+        
+        # Should only have port (no defaults used)
+        expected_values = {
+            "port": 8080
+        }
+        
+        assert values == expected_values
+
+
+def test_force_and_skip_defaults_combined(tmp_path):
+    """Test --force and --skip-defaults together."""
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        # Create schema
+        schema_data = {
+            "version": "1.0",
+            "values": [
+                {
+                    "key": "app-name",
+                    "path": "app.name",
+                    "description": "Application name",
+                    "type": "string",
+                    "required": False,
+                    "default": "myapp"
+                },
+                {
+                    "key": "port",
+                    "path": "app.port",
+                    "description": "Application port",
+                    "type": "number",
+                    "required": True
+                },
+                {
+                    "key": "optional-port",
+                    "path": "app.optionalPort",
+                    "description": "Optional port",
+                    "type": "number",
+                    "required": False
+                }
+            ]
+        }
+        
+        with open("schema.json", "w") as f:
+            json.dump(schema_data, f, indent=2)
+        
+        # Test both flags together
+        result = runner.invoke(app, [
+            "values", "init",
+            "--env", "test",
+            "--force",
+            "--skip-defaults"
+        ], input="8080\n")  # Input for required port
+        
+        assert result.exit_code == 0
+        
+        # Check output messages
+        assert "Skipping field with default value" in result.output  # app-name skipped
+        assert "Required field with no default, prompting" in result.output  # port prompted
+        assert "Skipping optional field without default" in result.output  # optional-port skipped
+        
+        # Check generated values file
+        with open("values-test.json") as f:
+            values = json.load(f)
+        
+        # Should only have port
+        expected_values = {
+            "port": 8080
+        }
+        
+        assert values == expected_values
+
+
+def test_force_mode_help_text():
+    """Test that help text is updated correctly."""
+    result = runner.invoke(app, ["values", "init", "--help"])
+    assert result.exit_code == 0
+    # Check that the help text contains key phrases (may be wrapped across lines)
+    assert "required fields without defaults" in result.output
+    assert "--skip-defaults" in result.output
+    assert "Skip fields with default values entirely" in result.output

tests/test_values_init.py

@@ -60,27 +60,31 @@ def create_test_schema_for_init():
 
 
 def test_values_init_force_mode_with_defaults(tmp_path):
-    """Test init command in force mode uses defaults where available."""
+    """Test init command in force mode uses defaults and prompts for required fields without defaults."""
     with runner.isolated_filesystem(temp_dir=tmp_path):
         schema = create_test_schema_for_init()
         with open("schema.json", "w") as f:
             json.dump(schema.model_dump(), f)
 
-        result = runner.invoke(app, ["values", "init", "--env", "dev", "--force"])
+        # Force mode now prompts for required fields without defaults
+        # Order: api-key first (1 for env, SECRET_KEY for name), then port (8080)
+        result = runner.invoke(app, ["values", "init", "--env", "dev", "--force"], 
+                             input="1\nSECRET_KEY\n8080\n")
 
         assert result.exit_code == 0
         assert "Using default value: myapp" in result.output
         assert "Using default value: False" in result.output
-        assert "Required field with no default, skipping" in result.output  # port and api-key
+        assert "Required field with no default, prompting" in result.output  # port and api-key
 
         # Check saved values (flat structure)
         with open("values-dev.json") as f:
             values = json.load(f)
 
         assert values["app-name"] == "myapp"
         assert values["debug"] is False
-        assert "port" not in values  # Required but no default
-        assert "api-key" not in values  # Required but sensitive
+        assert values["port"] == 8080  # Now included because we prompted for it
+        assert values["api-key"]["type"] == "env"  # Secret now set up
+        assert values["api-key"]["name"] == "SECRET_KEY"
 
 
 def test_values_init_interactive_set_values(tmp_path):
@@ -258,7 +262,7 @@ def test_values_init_custom_schema_and_values_path(tmp_path):
             "--schema", "config/custom-schema.json",
             "--values", "config/custom-values-custom.json",
             "--force"
-        ])
+        ], input="1\nCUSTOM_SECRET\n8080\n")  # Input order: api-key secret, then port
 
         assert result.exit_code == 0