mcp-souschef 2.8.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

souschef/converters/resource.py

@@ -30,20 +30,14 @@ def _parse_properties(properties_str: str) -> dict[str, Any]:
     if not properties_str:
         return {}
     try:
-        # Try ast.literal_eval first for safety
+        # Use ast.literal_eval for safe parsing of Python literals
         result = ast.literal_eval(properties_str)
         if isinstance(result, dict):
             return result
         return {}
     except (ValueError, SyntaxError):
-        # Fallback to eval if needed, but this is less safe
-        try:
-            result = eval(properties_str)  # noqa: S307
-            if isinstance(result, dict):
-                return result
-            return {}
-        except Exception:
-            return {}
+        # If parsing fails, return empty dict rather than using unsafe eval
+        return {}
 
 
 def _normalize_template_value(value: Any) -> Any:
@@ -245,13 +239,17 @@ def _get_include_recipe_params(
     Build parameters for include_recipe resources.
 
     Uses cookbook-specific configurations when available.
+    Falls back to include_role for unknown cookbooks.
     """
     cookbook_config = get_cookbook_package_config(resource_name)
     if cookbook_config:
         # Return a copy to prevent callers from mutating the shared mapping.
         return dict(cookbook_config["params"])
-    # Default behavior for recipes without a specific mapping.
-    return {"name": resource_name, "state": "present"}
+
+    # For unknown cookbooks, use include_role with the cookbook name
+    # Extract cookbook name from "cookbook::recipe" format
+    cookbook_name = resource_name.split("::")[0]
+    return {"name": cookbook_name}
 
 
 def _get_default_params(resource_name: str, action: str) -> dict[str, Any]:
@@ -303,6 +301,9 @@ def _convert_chef_resource_to_ansible(
         cookbook_config = get_cookbook_package_config(resource_name)
         if cookbook_config:
             ansible_module = cookbook_config["module"]
+        else:
+            # For include_recipe without specific mapping, use include_role
+            ansible_module = "ansible.builtin.include_role"
 
     # Handle unknown resource types
     if ansible_module is None:

souschef/converters/template.py

@@ -0,0 +1,177 @@
+"""Chef ERB template to Jinja2 converter."""
+
+from pathlib import Path
+
+from souschef.parsers.template import (
+    _convert_erb_to_jinja2,
+    _extract_template_variables,
+)
+
+
+def convert_template_file(erb_path: str) -> dict:
+    """
+    Convert an ERB template file to Jinja2 format.
+
+    Args:
+        erb_path: Path to the ERB template file.
+
+    Returns:
+        Dictionary containing:
+            - success: bool, whether conversion succeeded
+            - original_file: str, path to original ERB file
+            - jinja2_file: str, suggested path for .j2 file
+            - jinja2_content: str, converted Jinja2 template content
+            - variables: list, variables found in template
+            - error: str (optional), error message if conversion failed
+
+    """
+    try:
+        file_path = Path(erb_path).resolve()
+
+        if not file_path.exists():
+            return {
+                "success": False,
+                "error": f"File not found: {erb_path}",
+                "original_file": erb_path,
+            }
+
+        if not file_path.is_file():
+            return {
+                "success": False,
+                "error": f"Path is not a file: {erb_path}",
+                "original_file": erb_path,
+            }
+
+        # Read ERB template
+        try:
+            content = file_path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            return {
+                "success": False,
+                "error": f"Unable to decode {erb_path} as UTF-8 text",
+                "original_file": str(file_path),
+            }
+
+        # Extract variables
+        variables = _extract_template_variables(content)
+
+        # Convert ERB to Jinja2
+        jinja2_content = _convert_erb_to_jinja2(content)
+
+        # Determine output file name
+        jinja2_file = str(file_path).replace(".erb", ".j2")
+
+        return {
+            "success": True,
+            "original_file": str(file_path),
+            "jinja2_file": jinja2_file,
+            "jinja2_content": jinja2_content,
+            "variables": sorted(variables),
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Conversion failed: {e}",
+            "original_file": erb_path,
+        }
+
+
+def convert_cookbook_templates(cookbook_path: str) -> dict:
+    """
+    Convert all ERB templates in a cookbook to Jinja2.
+
+    Args:
+        cookbook_path: Path to the cookbook directory.
+
+    Returns:
+        Dictionary containing:
+            - success: bool, whether all conversions succeeded
+            - templates_converted: int, number of templates successfully converted
+            - templates_failed: int, number of templates that failed conversion
+            - results: list of dict, individual template conversion results
+            - error: str (optional), error message if cookbook not found
+
+    """
+    try:
+        cookbook_dir = Path(cookbook_path).resolve()
+
+        if not cookbook_dir.exists():
+            return {
+                "success": False,
+                "error": f"Cookbook directory not found: {cookbook_path}",
+                "templates_converted": 0,
+                "templates_failed": 0,
+                "results": [],
+            }
+
+        # Find all .erb files in the cookbook
+        erb_files = list(cookbook_dir.glob("**/*.erb"))
+
+        if not erb_files:
+            return {
+                "success": True,
+                "templates_converted": 0,
+                "templates_failed": 0,
+                "results": [],
+                "message": "No ERB templates found in cookbook",
+            }
+
+        results = []
+        templates_converted = 0
+        templates_failed = 0
+
+        for erb_file in erb_files:
+            result = convert_template_file(str(erb_file))
+            results.append(result)
+
+            if result["success"]:
+                templates_converted += 1
+            else:
+                templates_failed += 1
+
+        return {
+            "success": templates_failed == 0,
+            "templates_converted": templates_converted,
+            "templates_failed": templates_failed,
+            "results": results,
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Failed to convert cookbook templates: {e}",
+            "templates_converted": 0,
+            "templates_failed": 0,
+            "results": [],
+        }
+
+
+def convert_template_with_ai(erb_path: str, ai_service=None) -> dict:
+    """
+    Convert an ERB template to Jinja2 using AI assistance for complex conversions.
+
+    This function first attempts rule-based conversion, then optionally uses AI
+    for validation or complex Ruby logic that can't be automatically converted.
+
+    Args:
+        erb_path: Path to the ERB template file.
+        ai_service: Optional AI service instance for complex conversions.
+
+    Returns:
+        Dictionary with conversion results (same format as convert_template_file).
+
+    """
+    # Start with rule-based conversion
+    result = convert_template_file(erb_path)
+
+    # Add conversion method metadata
+    result["conversion_method"] = "rule-based"
+
+    # Future enhancement: Use AI service to validate/improve complex conversions
+    if ai_service is not None:
+        # AI validation/improvement logic deferred to future enhancement
+        # when AI integration becomes more critical to the template conversion process
+        pass
+
+    return result

souschef/core/__init__.py

@@ -50,7 +50,11 @@ from souschef.core.errors import (
     validate_directory_exists,
     validate_file_exists,
 )
-from souschef.core.path_utils import _normalize_path, _safe_join
+from souschef.core.path_utils import (
+    _ensure_within_base_path,
+    _normalize_path,
+    _safe_join,
+)
 from souschef.core.ruby_utils import _normalize_ruby_value
 from souschef.core.validation import (
     ValidationCategory,
@@ -63,6 +67,7 @@ __all__ = [
     "_normalize_path",
     "_normalize_ruby_value",
     "_safe_join",
+    "_ensure_within_base_path",
     "ValidationCategory",
     "ValidationEngine",
     "ValidationLevel",

souschef/core/metrics.py

@@ -0,0 +1,313 @@
+"""Centralized metrics and effort calculation module for consistent time estimations."""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import NamedTuple
+
+__all__ = [
+    "ComplexityLevel",
+    "EffortMetrics",
+    "convert_days_to_hours",
+    "convert_days_to_weeks",
+    "convert_hours_to_days",
+    "estimate_effort_for_complexity",
+    "get_team_recommendation",
+    "get_timeline_weeks",
+]
+
+
+class ComplexityLevel(str, Enum):
+    """Standard complexity levels used across all components."""
+
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+@dataclass
+class EffortMetrics:
+    """
+    Centralized container for all effort estimates.
+
+    Provides consistent representations across different formats:
+    - Base unit: person-days (with decimal precision)
+    - Derived: hours, weeks with consistent conversion factors
+    - Ranges: For display purposes, converting days to week ranges
+
+    Ensures all components (migration planning, dependency mapping,
+    validation reports) use the same underlying numbers.
+    """
+
+    estimated_days: float
+    """Base unit: person-days (e.g., 2.5, 5.0, 10.0)"""
+
+    @property
+    def estimated_hours(self) -> float:
+        """Convert days to hours using standard 8-hour workday."""
+        return self.estimated_days * 8
+
+    @property
+    def estimated_weeks_low(self) -> int:
+        """Conservative estimate: assumes optimal parallelization."""
+        return max(1, int(self.estimated_days / 7))
+
+    @property
+    def estimated_weeks_high(self) -> int:
+        """Realistic estimate: assumes sequential/limited parallelization."""
+        return max(1, int(self.estimated_days / 3.5))
+
+    @property
+    def estimated_weeks_range(self) -> str:
+        """Human-readable week range (e.g., '2-4 weeks')."""
+        low = self.estimated_weeks_low
+        high = self.estimated_weeks_high
+        if low == high:
+            return f"{low} week{'s' if low != 1 else ''}"
+        return f"{low}-{high} weeks"
+
+    @property
+    def estimated_days_formatted(self) -> str:
+        """Formatted days with appropriate precision."""
+        if self.estimated_days == int(self.estimated_days):
+            return f"{int(self.estimated_days)} days"
+        return f"{self.estimated_days:.1f} days"
+
+    def __str__(self) -> str:
+        """Return a string representation of effort metrics."""
+        return f"{self.estimated_days_formatted} ({self.estimated_weeks_range})"
+
+
+class TeamRecommendation(NamedTuple):
+    """Team composition and timeline recommendation."""
+
+    team_size: str
+    """e.g., '1 developer + 1 reviewer'"""
+
+    timeline_weeks: int
+    """Recommended timeline in weeks"""
+
+    description: str
+    """Human-readable description of the recommendation"""
+
+
+# Conversion constants - Single source of truth
+HOURS_PER_WORKDAY = 8
+DAYS_PER_WEEK = 7
+
+# Complexity thresholds for automatic categorization
+COMPLEXITY_THRESHOLD_LOW = 30
+COMPLEXITY_THRESHOLD_HIGH = 70
+
+# Effort multiplier per resource (base 1 resource = baseline effort)
+EFFORT_MULTIPLIER_PER_RESOURCE = 0.125  # 0.125 days = 1 hour per resource
+
+
+def convert_days_to_hours(days: float) -> float:
+    """Convert person-days to hours using standard 8-hour workday."""
+    return days * HOURS_PER_WORKDAY
+
+
+def convert_hours_to_days(hours: float) -> float:
+    """Convert hours to person-days using standard 8-hour workday."""
+    return hours / HOURS_PER_WORKDAY
+
+
+def convert_days_to_weeks(days: float, conservative: bool = False) -> int:
+    """
+    Convert days to weeks estimate.
+
+    Args:
+        days: Number of person-days
+        conservative: If True, use realistic estimate (1 engineer, limited
+            parallelization). If False, use optimistic estimate (full
+            parallelization)
+
+    Returns:
+        Number of weeks (integer)
+
+    """
+    weeks = days / 3.5 if conservative else days / DAYS_PER_WEEK
+    return max(1, int(weeks))
+
+
+def estimate_effort_for_complexity(
+    complexity_score: float, resource_count: int = 1
+) -> EffortMetrics:
+    """
+    Estimate effort based on complexity score and resource count.
+
+    Provides consistent effort estimation across all components.
+
+    Formula:
+    - Base effort: resource_count * 0.125 days per recipe/resource
+    - Complexity multiplier: 1.0 + (complexity_score / 100)
+    - Final effort: base_effort * complexity_multiplier
+
+    Args:
+        complexity_score: Score from 0-100 (0=simple, 100=complex)
+        resource_count: Number of resources to migrate (recipes, templates, etc.)
+
+    Returns:
+        EffortMetrics object with all representations
+
+    """
+    base_effort = resource_count * EFFORT_MULTIPLIER_PER_RESOURCE
+    complexity_multiplier = 1.0 + (complexity_score / 100)
+    estimated_days = base_effort * complexity_multiplier
+
+    return EffortMetrics(estimated_days=round(estimated_days, 1))
+
+
+def categorize_complexity(score: float) -> ComplexityLevel:
+    """
+    Categorize complexity score into standard levels.
+
+    Consistent thresholds across all components:
+    - Low: 0-29
+    - Medium: 30-69
+    - High: 70-100
+
+    Args:
+        score: Complexity score from 0-100
+
+    Returns:
+        ComplexityLevel enum value
+
+    """
+    if score < COMPLEXITY_THRESHOLD_LOW:
+        return ComplexityLevel.LOW
+    elif score < COMPLEXITY_THRESHOLD_HIGH:
+        return ComplexityLevel.MEDIUM
+    else:
+        return ComplexityLevel.HIGH
+
+
+def get_team_recommendation(total_effort_days: float) -> TeamRecommendation:
+    """
+    Get team composition and timeline recommendation based on total effort.
+
+    Consistent recommendations across all components.
+
+    Args:
+        total_effort_days: Total person-days of effort
+
+    Returns:
+        TeamRecommendation with team size and timeline
+
+    """
+    if total_effort_days < 20:
+        return TeamRecommendation(
+            team_size="1 developer + 1 reviewer",
+            timeline_weeks=4,
+            description="Single developer with oversight",
+        )
+    elif total_effort_days < 50:
+        return TeamRecommendation(
+            team_size="2 developers + 1 senior reviewer",
+            timeline_weeks=6,
+            description="Small dedicated team",
+        )
+    else:
+        return TeamRecommendation(
+            team_size="3-4 developers + 1 tech lead + 1 architect",
+            timeline_weeks=10,
+            description="Large dedicated migration team",
+        )
+
+
+def get_timeline_weeks(total_effort_days: float, strategy: str = "phased") -> int:
+    """
+    Calculate recommended timeline in weeks based on effort and strategy.
+
+    Consistent timeline calculation across planning, dependency mapping, and reports.
+
+    Args:
+        total_effort_days: Total person-days estimated
+        strategy: Migration strategy ('phased', 'big_bang', 'parallel')
+
+    Returns:
+        Recommended timeline in weeks
+
+    """
+    # Base calculation: distribute effort across team capacity
+    # Assume 3-5 person-days of output per week with normal team capacity
+    base_weeks = max(2, int(total_effort_days / 4.5))
+
+    # Apply strategy adjustments
+    if strategy == "phased":
+        # Phased adds overhead for testing between phases
+        return int(base_weeks * 1.1)
+    elif strategy == "big_bang":
+        # Big bang is faster but riskier
+        return int(base_weeks * 0.9)
+    else:  # parallel
+        # Parallel has some overhead for coordination
+        return int(base_weeks * 1.05)
+
+
+def validate_metrics_consistency(
+    days: float, weeks: str, hours: float, complexity: str
+) -> tuple[bool, list[str]]:
+    """
+    Validate that different metric representations are consistent.
+
+    Used for validation reports to catch contradictions.
+
+    Args:
+        days: Days estimate
+        weeks: Weeks range string (e.g., "2-4 weeks")
+        hours: Hours estimate
+        complexity: Complexity level string
+
+    Returns:
+        Tuple of (is_valid, list_of_errors)
+
+    """
+    errors = []
+
+    # Check hours consistency
+    expected_hours = days * 8
+    if abs(hours - expected_hours) > 1.0:  # Allow 1 hour tolerance
+        errors.append(
+            f"Hours mismatch: {hours:.1f} hours but {days} days = "
+            f"{expected_hours:.1f} hours"
+        )
+
+    # Check weeks consistency (loose check due to range)
+    # Valid formats: "1 week", "1-2 weeks"
+    if "week" not in weeks.lower():
+        errors.append(f"Invalid weeks format: {weeks}")
+    elif "-" in weeks:
+        # Range format: "X-Y weeks"
+        try:
+            parts = weeks.replace(" weeks", "").replace(" week", "").split("-")
+            week_min = int(parts[0].strip())
+            week_max = int(parts[1].strip())
+            expected_weeks = int(days / 3.5)  # Conservative estimate
+
+            if not (week_min <= expected_weeks <= week_max + 1):
+                errors.append(
+                    f"Weeks mismatch: {weeks} but {days} days should be "
+                    f"approximately {expected_weeks} weeks"
+                )
+        except (ValueError, IndexError):
+            errors.append(f"Invalid weeks format: {weeks}")
+    else:
+        # Single week format: "X week" or "X weeks"
+        try:
+            num = int(weeks.replace(" weeks", "").replace(" week", "").strip())
+            expected_weeks = int(days / 3.5)
+            if num != expected_weeks and abs(num - expected_weeks) > 2:
+                errors.append(
+                    f"Weeks mismatch: {weeks} but {days} days should be "
+                    f"approximately {expected_weeks} weeks"
+                )
+        except ValueError:
+            errors.append(f"Invalid weeks format: {weeks}")
+
+    # Check complexity is valid
+    valid_complexities = {level.value for level in ComplexityLevel}
+    if complexity.lower() not in valid_complexities:
+        errors.append(f"Invalid complexity level: {complexity}")
+
+    return len(errors) == 0, errors