mcp-souschef 2.5.3__py3-none-any.whl → 3.0.0__py3-none-any.whl

souschef/converters/resource.py

@@ -2,9 +2,14 @@
 
 import ast
 import json
+import re
 from collections.abc import Callable
 from typing import Any
 
+from souschef.converters.cookbook_specific import (
+    build_cookbook_resource_params,
+    get_cookbook_package_config,
+)
 from souschef.core.constants import ACTION_TO_STATE, RESOURCE_MAPPINGS
 
 # Type alias for parameter builder functions
@@ -25,20 +30,59 @@ 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:
+    """Normalize Ruby-style attribute references into Jinja templates."""
+    if isinstance(value, str):
+        # Convert Chef node attributes to Ansible variables dynamically
+        def _replace_node_attr(match):
+            cookbook = match.group(1)
+            attr = match.group(2)
+
+            # Convert cookbook name to readable format
+            def char_to_word(c: str) -> str:
+                number_words = {
+                    "1": "one",
+                    "2": "two",
+                    "3": "three",
+                    "4": "four",
+                    "5": "five",
+                    "6": "six",
+                    "7": "seven",
+                    "8": "eight",
+                    "9": "nine",
+                    "0": "zero",
+                }
+                return number_words.get(c, c)
+
+            # Replace non-alphanumeric characters with underscores
+            readable_cookbook = "".join(
+                char_to_word(c) if c.isdigit() else (c if c.isalnum() else "_")
+                for c in cookbook
+            )
+
+            # Ensure we don't have multiple consecutive underscores
+            readable_cookbook = re.sub(r"_+", "_", readable_cookbook)
+            # Remove leading/trailing underscores
+            readable_cookbook = readable_cookbook.strip("_")
+
+            return f"{{{{ {readable_cookbook}_{attr} }}}}"
+
+        value = re.sub(r"node\['(\w+)'\]\['(\w+)'\]", _replace_node_attr, value)
+
+        # Wrap in Jinja if it's a node reference
+        if "node[" in value:
+            return f"{{{{ {value} }}}}"
+    return value
 
 
 def convert_resource_to_task(
@@ -188,6 +232,26 @@ def _get_remote_file_params(
     return params
 
 
+def _get_include_recipe_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """
+    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"])
+
+    # 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]:
     """Build default parameters for unknown resource types."""
     params = {"name": resource_name}
@@ -209,6 +273,7 @@ RESOURCE_PARAM_BUILDERS: dict[str, ParamBuilder | str] = {
     "user": _get_user_group_params,
     "group": _get_user_group_params,
     "remote_file": _get_remote_file_params,
+    "include_recipe": _get_include_recipe_params,
 }
 
 
@@ -229,7 +294,26 @@ def _convert_chef_resource_to_ansible(
 
     """
     # Get Ansible module name
-    ansible_module = RESOURCE_MAPPINGS.get(resource_type, f"# Unknown: {resource_type}")
+    ansible_module = RESOURCE_MAPPINGS.get(resource_type)
+
+    # Check for cookbook-specific include_recipe configurations
+    if resource_type == "include_recipe":
+        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:
+        # Return a task with just a comment for unknown resources
+        return {
+            "name": f"Create {resource_type} {resource_name}",
+            "# Unknown": f"{resource_type}:",
+            "resource_name": resource_name,
+            "state": "present",
+        }
 
     # Start building the task
     task: dict[str, Any] = {
@@ -242,6 +326,12 @@ def _convert_chef_resource_to_ansible(
     # Build module parameters using appropriate builder
     module_params = _build_module_params(resource_type, resource_name, action, props)
 
+    # Override with cookbook-specific params for include_recipe
+    if resource_type == "include_recipe":
+        cookbook_config = get_cookbook_package_config(resource_name)
+        if cookbook_config:
+            module_params = cookbook_config["params"].copy()
+
     # Add special task-level flags for execute/bash resources
     if resource_type in ["execute", "bash"]:
         task["changed_when"] = "false"
@@ -266,6 +356,13 @@ def _build_module_params(
         Dictionary of Ansible module parameters.
 
     """
+    # First check for cookbook-specific resource types
+    cookbook_params = build_cookbook_resource_params(
+        resource_type, resource_name, action, props
+    )
+    if cookbook_params is not None:
+        return cookbook_params
+
     # Look up the parameter builder for this resource type
     builder = RESOURCE_PARAM_BUILDERS.get(resource_type)
 
@@ -297,6 +394,8 @@ def _format_dict_value(key: str, value: dict[str, Any]) -> list[str]:
     """Format a dictionary value for YAML output."""
     lines = [f"  {key}:"]
     for param_key, param_value in value.items():
+        # Indent nested params by four spaces so downstream formatting nests
+        # module parameters under the module key.
         lines.append(f"    {param_key}: {_format_yaml_value(param_value)}")
     return lines
 
@@ -317,6 +416,10 @@ def _format_ansible_task(task: dict[str, Any]) -> str:
     for key, value in task.items():
         if key == "name":
             continue
+        if key == "# Unknown":
+            # Handle unknown resources with a comment
+            result.append(f"  # {value}")
+            continue
         if isinstance(value, dict):
             result.extend(_format_dict_value(key, value))
         else:

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/constants.py

@@ -1,10 +1,13 @@
 """Constants used throughout SousChef."""
 
 __all__ = [
+    "VERSION",
     "ANSIBLE_SERVICE_MODULE",
     "METADATA_FILENAME",
     "ERROR_PREFIX",
     "NODE_PREFIX",
+    "ATTRIBUTE_PREFIX",
+    "VALUE_PREFIX",
     "CHEF_RECIPE_PREFIX",
     "CHEF_ROLE_PREFIX",
     "REGEX_WHITESPACE_QUOTE",
@@ -39,6 +42,9 @@ __all__ = [
     "ACTION_TO_STATE",
 ]
 
+# Version
+VERSION = "2.6.0"
+
 # Ansible module names
 ANSIBLE_SERVICE_MODULE = "ansible.builtin.service"
 
@@ -48,6 +54,8 @@ METADATA_FILENAME = "metadata.rb"
 # Common prefixes
 ERROR_PREFIX = "Error:"
 NODE_PREFIX = "node["
+ATTRIBUTE_PREFIX = "Attribute: "
+VALUE_PREFIX = "Value: "
 CHEF_RECIPE_PREFIX = "recipe["
 CHEF_ROLE_PREFIX = "role["
 
@@ -126,6 +134,11 @@ RESOURCE_MAPPINGS = {
     "mount": "ansible.builtin.mount",
     "git": "ansible.builtin.git",
     "remote_file": "ansible.builtin.get_url",
+    "nodejs_npm": "community.general.npm",
+    # Map include_recipe to a generic package install so well-known recipes
+    # (like nodejs) can be materialised into concrete tasks instead of
+    # producing stubbed import_role calls.
+    "include_recipe": "ansible.builtin.package",
 }
 
 # Chef action to Ansible state mappings