feat(config): validate CLI overrides

Author: Really Him

src/antipasta/cli/config_generate.py

@@ -8,35 +8,46 @@
 import click
 from pydantic import ValidationError
 
+from antipasta.cli.validation_utils import get_metric_constraints
 from antipasta.core.config import AntipastaConfig
+from antipasta.core.metric_models import MetricThresholds
 
 
-def validate_positive_int(value: str, min_val: int = 1, max_val: int | None = None) -> int:
-    """Validate a positive integer within optional range."""
-    try:
-        num = int(value)
-        if num < min_val:
-            raise click.BadParameter(f"Value must be at least {min_val}")
-        if max_val is not None and num > max_val:
-            raise click.BadParameter(f"Value must be at most {max_val}")
-        return num
-    except ValueError as e:
-        raise click.BadParameter("Must be a valid integer") from e
+def validate_with_pydantic(metric_type: str, value: str) -> float:
+    """Validate a metric value using Pydantic model.
 
+    Args:
+        metric_type: The metric type being validated
+        value: String value to validate
 
-def validate_positive_float(
-    value: str, min_val: float = 0.0, max_val: float | None = None
-) -> float:
-    """Validate a positive float within optional range."""
+    Returns:
+        Validated numeric value
+
+    Raises:
+        click.BadParameter: If validation fails
+    """
     try:
         num = float(value)
-        if num < min_val:
-            raise click.BadParameter(f"Value must be at least {min_val}")
-        if max_val is not None and num > max_val:
-            raise click.BadParameter(f"Value must be at most {max_val}")
+        # Use Pydantic validation
+        MetricThresholds(**{metric_type: num})
         return num
-    except ValueError as e:
-        raise click.BadParameter("Must be a valid number") from e
+    except ValidationError as e:
+        # Extract first error message
+        if e.errors():
+            err = e.errors()[0]
+            err_type = err.get('type', '')
+            ctx = err.get('ctx', {})
+
+            if 'greater_than_equal' in err_type:
+                raise click.BadParameter(f"Value must be >= {ctx.get('ge', 0)}")
+            elif 'less_than_equal' in err_type:
+                raise click.BadParameter(f"Value must be <= {ctx.get('le', 'max')}")
+            elif err_type == 'int_type':
+                raise click.BadParameter(f"Must be an integer")
+
+        raise click.BadParameter(str(e))
+    except ValueError:
+        raise click.BadParameter("Must be a valid number")
 
 
 def prompt_with_validation(
@@ -98,25 +109,29 @@ def generate(output: Path, non_interactive: bool) -> None:
     click.echo("\nLet's set up your code quality thresholds:")
     click.echo("-" * 40)
 
+    # Get constraints from Pydantic model
+    cc_min, cc_max = get_metric_constraints('cyclomatic_complexity')
     max_cyclomatic = prompt_with_validation(
         "Maximum cyclomatic complexity per function",
         default=10,
-        validator=lambda v: validate_positive_int(v, min_val=1, max_val=50),
-        help_text="ℹ️  Range: 1-50 (lower is stricter). Recommended: 10",
+        validator=lambda v: validate_with_pydantic('cyclomatic_complexity', v),
+        help_text=f"ℹ️  Range: {cc_min}-{cc_max} (lower is stricter). Recommended: 10",
     )
 
+    cog_min, cog_max = get_metric_constraints('cognitive_complexity')
     max_cognitive = prompt_with_validation(
         "Maximum cognitive complexity per function",
         default=15,
-        validator=lambda v: validate_positive_int(v, min_val=1, max_val=100),
-        help_text="ℹ️  Range: 1-100 (lower is stricter). Recommended: 15",
+        validator=lambda v: validate_with_pydantic('cognitive_complexity', v),
+        help_text=f"ℹ️  Range: {cog_min}-{cog_max} (lower is stricter). Recommended: 15",
     )
 
+    mi_min, mi_max = get_metric_constraints('maintainability_index')
     min_maintainability = prompt_with_validation(
         "Minimum maintainability index",
         default=50,
-        validator=lambda v: validate_positive_int(v, min_val=0, max_val=100),
-        help_text="ℹ️  Range: 0-100 (higher is stricter). Recommended: 50",
+        validator=lambda v: validate_with_pydantic('maintainability_index', v),
+        help_text=f"ℹ️  Range: {mi_min}-{mi_max} (higher is stricter). Recommended: 50",
     )
 
     # Ask about advanced metrics
@@ -135,25 +150,28 @@ def generate(output: Path, non_interactive: bool) -> None:
         click.echo("\nAdvanced Halstead metrics:")
         click.echo("-" * 40)
 
+        hv_min, hv_max = get_metric_constraints('halstead_volume')
         defaults_dict["max_halstead_volume"] = prompt_with_validation(
             "Maximum Halstead volume",
             default=1000,
-            validator=lambda v: validate_positive_float(v, min_val=1, max_val=100000),
-            help_text="ℹ️  Range: 1-100000. Measures program size. Recommended: 1000",
+            validator=lambda v: validate_with_pydantic('halstead_volume', v),
+            help_text=f"ℹ️  Range: {hv_min}-{hv_max}. Measures program size. Recommended: 1000",
         )
 
+        hd_min, hd_max = get_metric_constraints('halstead_difficulty')
         defaults_dict["max_halstead_difficulty"] = prompt_with_validation(
             "Maximum Halstead difficulty",
             default=10,
-            validator=lambda v: validate_positive_float(v, min_val=0.1, max_val=100),
-            help_text="ℹ️  Range: 0.1-100. Measures error proneness. Recommended: 10",
+            validator=lambda v: validate_with_pydantic('halstead_difficulty', v),
+            help_text=f"ℹ️  Range: {hd_min}-{hd_max}. Measures error proneness. Recommended: 10",
         )
 
+        he_min, he_max = get_metric_constraints('halstead_effort')
         defaults_dict["max_halstead_effort"] = prompt_with_validation(
             "Maximum Halstead effort",
             default=10000,
-            validator=lambda v: validate_positive_float(v, min_val=1, max_val=1000000),
-            help_text="ℹ️  Range: 1-1000000. Measures implementation time. Recommended: 10000",
+            validator=lambda v: validate_with_pydantic('halstead_effort', v),
+            help_text=f"ℹ️  Range: {he_min}-{he_max}. Measures implementation time. Recommended: 10000",
         )
     else:
         # Use defaults for advanced metrics

src/antipasta/cli/metrics.py

@@ -7,6 +7,7 @@
 
 import click
 
+from antipasta.cli.validation_utils import format_validation_error_for_cli, get_metric_help_text
 from antipasta.core.aggregator import MetricAggregator
 from antipasta.core.config import AntipastaConfig
 from antipasta.core.config_override import ConfigOverride
@@ -112,7 +113,15 @@ def metrics(
         try:
             override.parse_threshold_string(threshold_str)
         except ValueError as e:
-            click.echo(f"Error parsing threshold override: {e}", err=True)
+            click.echo(f"❌ Error: {format_validation_error_for_cli(e)}", err=True)
+
+            # If it's a range error, show the valid range
+            if '=' in threshold_str:
+                metric_type = threshold_str.split('=')[0].strip()
+                help_text = get_metric_help_text(metric_type)
+                if help_text and metric_type in help_text:
+                    click.echo(f"   ℹ️  {help_text}", err=True)
+
             sys.exit(1)
 
     # Apply overrides to configuration

src/antipasta/cli/validation_utils.py

@@ -0,0 +1,116 @@
+"""Utilities for extracting validation info from Pydantic schemas.
+
+This module provides helper functions to extract constraint information
+from Pydantic models and format them for CLI help text and error messages.
+"""
+
+from typing import Optional, Tuple
+
+from antipasta.core.metric_models import MetricThresholds
+
+
+def get_metric_constraints(metric_type: str) -> Tuple[Optional[float], Optional[float]]:
+    """Get min/max constraints for a metric from Pydantic schema.
+
+    Args:
+        metric_type: The metric type to get constraints for
+
+    Returns:
+        Tuple of (min_value, max_value), either can be None
+    """
+    schema = MetricThresholds.model_json_schema()
+    properties = schema.get('properties', {})
+
+    if metric_type in properties:
+        prop_schema = properties[metric_type]
+
+        # Handle anyOf schemas (used for Optional fields)
+        if 'anyOf' in prop_schema:
+            # Find the non-null schema
+            for sub_schema in prop_schema['anyOf']:
+                if sub_schema.get('type') != 'null':
+                    prop_schema = sub_schema
+                    break
+
+        min_val = prop_schema.get('minimum')
+        max_val = prop_schema.get('maximum')
+
+        # Also check for exclusive bounds
+        if min_val is None:
+            min_val = prop_schema.get('exclusiveMinimum')
+        if max_val is None:
+            max_val = prop_schema.get('exclusiveMaximum')
+
+        return (min_val, max_val)
+
+    return (None, None)
+
+
+def get_metric_help_text(metric_type: str) -> str:
+    """Get help text for a metric including its valid range.
+
+    Args:
+        metric_type: The metric type to get help text for
+
+    Returns:
+        Help text string with description and valid range
+    """
+    schema = MetricThresholds.model_json_schema()
+    properties = schema.get('properties', {})
+
+    if metric_type in properties:
+        prop_schema = properties[metric_type]
+
+        # Handle anyOf schemas
+        if 'anyOf' in prop_schema:
+            for sub_schema in prop_schema['anyOf']:
+                if sub_schema.get('type') != 'null':
+                    prop_schema = sub_schema
+                    break
+
+        description = prop_schema.get('description', '')
+
+        # Extract range from schema
+        min_val, max_val = get_metric_constraints(metric_type)
+
+        range_parts = []
+        if min_val is not None:
+            range_parts.append(f">= {min_val}")
+        if max_val is not None:
+            range_parts.append(f"<= {max_val}")
+
+        if range_parts:
+            range_text = " and ".join(range_parts)
+            if description:
+                # Extract just the description part without existing range
+                if '(' in description:
+                    description = description.split('(')[0].strip()
+                return f"{description} (valid: {range_text})"
+            else:
+                return f"Valid range: {range_text}"
+
+        return description if description else f"Metric: {metric_type}"
+
+    return f"Metric: {metric_type}"
+
+
+def format_validation_error_for_cli(e: Exception) -> str:
+    """Format validation errors for CLI display.
+
+    Args:
+        e: The exception to format
+
+    Returns:
+        User-friendly error message
+    """
+    error_msg = str(e)
+
+    # Make error messages more user-friendly
+    if "Invalid metric type" in error_msg:
+        # The error already lists valid types
+        return error_msg
+    elif "must be" in error_msg:
+        # Range errors are already clear
+        return error_msg
+    else:
+        return f"Validation error: {error_msg}"

src/antipasta/core/config.py

@@ -11,8 +11,16 @@
 from typing import TYPE_CHECKING
 
 import yaml
-from pydantic import BaseModel, Field, field_validator, model_validator
-
+from pydantic import BaseModel, Field, field_validator
+
+from antipasta.core.metric_models import (
+    CognitiveComplexity,
+    CyclomaticComplexity,
+    HalsteadDifficulty,
+    HalsteadEffort,
+    HalsteadVolume,
+    MaintainabilityIndex,
+)
 from antipasta.core.metrics import MetricType
 
 if TYPE_CHECKING:
@@ -65,22 +73,18 @@ def validate_extensions(cls, v: list[str]) -> list[str]:
 
 
 class DefaultsConfig(BaseModel):
-    """Default configuration values."""
-
-    max_cyclomatic_complexity: float = 10
-    min_maintainability_index: float = 50
-    max_halstead_volume: float = 1000
-    max_halstead_difficulty: float = 10
-    max_halstead_effort: float = 10000
-    max_cognitive_complexity: float = 15
-
-    @model_validator(mode="after")
-    def validate_defaults(self) -> DefaultsConfig:
-        """Ensure all values are positive."""
-        for field_name, value in self.model_dump().items():
-            if value < 0:
-                raise ValueError(f"{field_name} must be non-negative")
-        return self
+    """Default configuration values with automatic validation.
+
+    All validation is handled by Pydantic Field constraints,
+    no custom validators needed.
+    """
+
+    max_cyclomatic_complexity: CyclomaticComplexity = 10
+    min_maintainability_index: MaintainabilityIndex = 50
+    max_halstead_volume: HalsteadVolume = 1000
+    max_halstead_difficulty: HalsteadDifficulty = 10
+    max_halstead_effort: HalsteadEffort = 10000
+    max_cognitive_complexity: CognitiveComplexity = 15
 
 
 class AntipastaConfig(BaseModel):