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

souschef/converters/playbook.py

@@ -98,6 +98,7 @@ def generate_playbook_from_recipe_with_ai(
     max_tokens: int = 4000,
     project_id: str = "",
     base_url: str = "",
+    project_recommendations: dict | None = None,
 ) -> str:
     """
     Generate an AI-enhanced Ansible playbook from a Chef recipe.
@@ -116,6 +117,8 @@ def generate_playbook_from_recipe_with_ai(
         max_tokens: Maximum tokens to generate.
         project_id: Project ID for IBM Watsonx (required for watson provider).
         base_url: Custom base URL for the AI provider.
+        project_recommendations: Dictionary containing project-level analysis
+            and recommendations from cookbook assessment.
 
     Returns:
         AI-generated Ansible playbook in YAML format.
@@ -146,6 +149,7 @@ def generate_playbook_from_recipe_with_ai(
             max_tokens,
             project_id,
             base_url,
+            project_recommendations,
         )
 
         return ai_playbook
@@ -165,6 +169,7 @@ def _generate_playbook_with_ai(
     max_tokens: int,
     project_id: str = "",
     base_url: str = "",
+    project_recommendations: dict | None = None,
 ) -> str:
     """Generate Ansible playbook using AI for intelligent conversion."""
     try:
@@ -174,7 +179,9 @@ def _generate_playbook_with_ai(
             return client
 
         # Create the AI prompt
-        prompt = _create_ai_conversion_prompt(raw_content, parsed_content, recipe_name)
+        prompt = _create_ai_conversion_prompt(
+            raw_content, parsed_content, recipe_name, project_recommendations
+        )
 
         # Call the AI API and get response
         ai_response = _call_ai_api(
@@ -333,96 +340,257 @@ def _call_ai_api(
 
 
 def _create_ai_conversion_prompt(
-    raw_content: str, parsed_content: str, recipe_name: str
+    raw_content: str,
+    parsed_content: str,
+    recipe_name: str,
+    project_recommendations: dict | None = None,
 ) -> str:
     """Create a comprehensive prompt for AI conversion."""
-    return f"""You are an expert at converting Chef recipes to Ansible playbooks.
-Your task is to convert the following Chef recipe into a high-quality,
-production-ready Ansible playbook.
-
-CHEF RECIPE CONTENT:
-{raw_content}
-
-PARSED RECIPE ANALYSIS:
-{parsed_content}
-
-RECIPE NAME: {recipe_name}
-
-CONVERSION REQUIREMENTS:
-
-1. **Understand the Intent**: Analyze what this Chef recipe is trying to
-   accomplish. Look at the resources, their properties, and the overall
-   workflow.
-
-2. **Best Practices**: Generate Ansible code that follows Ansible best
-   practices:
-   - Use appropriate modules (ansible.builtin.* when possible)
-   - Include proper error handling and idempotency
-   - Use meaningful variable names
-   - Include comments explaining complex logic
-   - Handle edge cases and failure scenarios
-
-3. **Resource Mapping**: Convert Chef resources to appropriate Ansible
-   modules:
-   - package → ansible.builtin.package or specific package managers
-   - service → ansible.builtin.service
-   - file/directory → ansible.builtin.file
-   - template → ansible.builtin.template
-   - execute → ansible.builtin.command/shell
-   - user/group → ansible.builtin.user/group
-   - mount → ansible.builtin.mount
-
-4. **Variables and Facts**: Convert Chef node attributes to Ansible
-   variables/facts appropriately.
-
-5. **Conditionals**: Convert Chef guards (only_if/not_if) to Ansible when
-   conditions.
-
-6. **Notifications**: Convert Chef notifications to Ansible handlers where
-   appropriate.
-
-7. **Idempotency**: Ensure the playbook is idempotent and can be run
-   multiple times safely.
-
-8. **Error Handling**: Include proper error handling and rollback
-   considerations.
-
-9. **Task Ordering**: CRITICAL: Ensure tasks are ordered logically.
-   - Install packages BEFORE configuring them.
-   - create users/groups BEFORE using them in file permissions.
-   - Place configuration files BEFORE starting/restarting services.
-   - Ensure directories exist BEFORE creating files in them.
-
-10. **Handlers**: Verify that all notified handlers are actually defined
-    in the handlers section.
-
-OUTPUT FORMAT:
-Return ONLY a valid YAML Ansible playbook. Do not include any explanation,
-markdown formatting, or code blocks. The output should be pure YAML that can
-be directly used as an Ansible playbook.
-
-The playbook should include:
-- A proper name
-- Appropriate hosts (default to 'all')
-- Variables section if needed
-- Tasks section with all converted resources
-- Handlers section if notifications are used
-- Any necessary pre_tasks or post_tasks
-
-Example structure:
----
-- name: Convert of {recipe_name}
-  hosts: all
-  become: true
-  vars:
-    # Variables here
-  tasks:
-    # Tasks here
-  handlers:
-    # Handlers here
-
-Focus on creating a functional, well-structured Ansible playbook that achieves
-the same outcome as the Chef recipe."""
+    prompt_parts = _build_base_prompt_parts(raw_content, parsed_content, recipe_name)
+
+    # Add project context if available
+    if project_recommendations:
+        prompt_parts.extend(
+            _build_project_context_parts(project_recommendations, recipe_name)
+        )
+
+    prompt_parts.extend(_build_conversion_requirements_parts())
+
+    # Add project-specific guidance if available
+    if project_recommendations:
+        prompt_parts.extend(_build_project_guidance_parts(project_recommendations))
+
+    prompt_parts.extend(_build_output_format_parts())
+
+    return "\n".join(prompt_parts)
+
+
+def _build_base_prompt_parts(
+    raw_content: str, parsed_content: str, recipe_name: str
+) -> list[str]:
+    """Build the base prompt parts."""
+    return [
+        "You are an expert at converting Chef recipes to Ansible playbooks.",
+        "Your task is to convert the following Chef recipe into a high-quality,",
+        "production-ready Ansible playbook.",
+        "",
+        "CHEF RECIPE CONTENT:",
+        raw_content,
+        "",
+        "PARSED RECIPE ANALYSIS:",
+        parsed_content,
+        "",
+        f"RECIPE NAME: {recipe_name}",
+    ]
+
+
+def _build_project_context_parts(
+    project_recommendations: dict, recipe_name: str
+) -> list[str]:
+    """Build project context parts."""
+    # Extract values to shorten f-strings
+    complexity = project_recommendations.get("project_complexity", "Unknown")
+    strategy = project_recommendations.get("migration_strategy", "Unknown")
+    effort_days = project_recommendations.get("project_effort_days", 0)
+    density = project_recommendations.get("dependency_density", 0)
+
+    parts = [
+        "",
+        "PROJECT CONTEXT:",
+        f"Project Complexity: {complexity}",
+        f"Migration Strategy: {strategy}",
+        f"Total Project Effort: {effort_days:.1f} days",
+        f"Dependency Density: {density:.2f}",
+    ]
+
+    # Add migration recommendations
+    recommendations = project_recommendations.get("recommendations", [])
+    if recommendations:
+        parts.extend(
+            [
+                "",
+                "PROJECT MIGRATION RECOMMENDATIONS:",
+            ]
+        )
+        for rec in recommendations[:5]:  # Limit to first 5 recommendations
+            parts.append(f"- {rec}")
+
+    # Add dependency information
+    migration_order = project_recommendations.get("migration_order", [])
+    if migration_order:
+        recipe_position = _find_recipe_position_in_migration_order(
+            migration_order, recipe_name
+        )
+        if recipe_position:
+            dependencies = ", ".join(recipe_position.get("dependencies", [])) or "None"
+            parts.extend(
+                [
+                    "",
+                    "MIGRATION CONTEXT FOR THIS RECIPE:",
+                    f"Phase: {recipe_position.get('phase', 'Unknown')}",
+                    f"Complexity: {recipe_position.get('complexity', 'Unknown')}",
+                    f"Dependencies: {dependencies}",
+                    f"Migration Reason: {recipe_position.get('reason', 'Unknown')}",
+                ]
+            )
+
+    return parts
+
+
+def _find_recipe_position_in_migration_order(
+    migration_order: list[dict[str, Any]], recipe_name: str
+) -> dict[str, Any] | None:
+    """Find this recipe's position in migration order."""
+    for item in migration_order:
+        cookbook_name = recipe_name.replace(".rb", "").replace("recipes/", "")
+        if item.get("cookbook") == cookbook_name:
+            return item
+    return None
+
+
+def _build_conversion_requirements_parts() -> list[str]:
+    """Build conversion requirements parts."""
+    return [
+        "",
+        "CONVERSION REQUIREMENTS:",
+        "",
+        "1. **Understand the Intent**: Analyze what this Chef recipe is trying to",
+        "   accomplish. Look at the resources, their properties, and the overall",
+        "   workflow.",
+        "",
+        "2. **Best Practices**: Generate Ansible code that follows Ansible best",
+        "   practices:",
+        "   - Use appropriate modules (ansible.builtin.* when possible)",
+        "   - Include proper error handling and idempotency",
+        "   - Use meaningful variable names",
+        "   - Include comments explaining complex logic",
+        "   - Handle edge cases and failure scenarios",
+        "",
+        "3. **Resource Mapping**: Convert Chef resources to appropriate Ansible",
+        "   modules:",
+        "   - package → ansible.builtin.package or specific package managers",
+        "   - service → ansible.builtin.service",
+        "   - file/directory → ansible.builtin.file",
+        "   - template → ansible.builtin.template (CHANGE .erb to .j2 extension)",
+        "   - execute → ansible.builtin.command/shell",
+        "   - user/group → ansible.builtin.user/group",
+        "   - mount → ansible.builtin.mount",
+        "   - include_recipe → ansible.builtin.include_role (for unknown cookbooks)",
+        "   - include_recipe → specific role imports (for known cookbooks)",
+        "",
+        "4. **Template Conversions**: CRITICAL for template resources:",
+        "   - Change file extension from .erb to .j2 in the 'src' parameter",
+        "   - Example: 'config.erb' becomes 'config.j2'",
+        "   - Add note: Templates need manual ERB→Jinja2 conversion",
+        "   - ERB syntax: <%= variable %> → Jinja2: {{ variable }}",
+        "   - ERB blocks: <% code %> → Jinja2: {% code %}",
+        "",
+        "5. **Chef Data Bags to Ansible Vault**: Convert data bag lookups:",
+        "   - Chef::EncryptedDataBagItem.load('bag', 'item') →",
+        "   - Ansible: Use group_vars/ or host_vars/ with ansible-vault",
+        "   - Store sensitive data in encrypted YAML files, not inline lookups",
+        "   - Example: Define ssh_key in group_vars/all/vault.yml (encrypted)",
+        "",
+        "6. **Variables and Facts**: Convert Chef node attributes to Ansible",
+        "   variables/facts appropriately:",
+        "   - node['attribute'] → {{ ansible_facts.attribute }} or vars",
+        "   - node['platform'] → {{ ansible_distribution }}",
+        "   - node['platform_version'] → {{ ansible_distribution_version }}",
+        "",
+        "7. **Conditionals**: Convert Chef guards (only_if/not_if) to Ansible when",
+        "   conditions.",
+        "",
+        "8. **Notifications**: Convert Chef notifications to Ansible handlers",
+        "   where appropriate.",
+        "",
+        "9. **Idempotency**: Ensure the playbook is idempotent and can be run",
+        "   multiple times safely.",
+        "",
+        "10. **Error Handling**: Include proper error handling and rollback",
+        "   considerations.",
+        "",
+        "11. **Task Ordering**: CRITICAL: Ensure tasks are ordered logically.",
+        "   - Install packages BEFORE configuring them.",
+        "   - create users/groups BEFORE using them in file permissions.",
+        "   - Place configuration files BEFORE starting/restarting services.",
+        "   - Ensure directories exist BEFORE creating files in them.",
+        "",
+        "12. **Handlers**: Verify that all notified handlers are actually defined",
+        "    in the handlers section.",
+    ]
+
+
+def _build_project_guidance_parts(project_recommendations: dict) -> list[str]:
+    """Build project-specific guidance parts."""
+    strategy = project_recommendations.get("migration_strategy", "").lower()
+    parts = []
+
+    if "parallel" in strategy:
+        parallel_tracks = project_recommendations.get("parallel_tracks", 2)
+        parts.extend(
+            [
+                "",
+                "11. **Parallel Migration Context**: This recipe is part of a",
+                f"    parallel migration with {parallel_tracks} tracks.",
+                "    Ensure this playbook can run independently without",
+                "    dependencies on other cookbooks in the project.",
+            ]
+        )
+    elif "phased" in strategy:
+        parts.extend(
+            [
+                "",
+                "11. **Phased Migration Context**: This recipe is part of a phased",
+                "    migration approach. Consider dependencies and ensure proper",
+                "    ordering within the broader project migration plan.",
+            ]
+        )
+
+    return parts
+
+
+def _build_output_format_parts() -> list[str]:
+    """Build output format parts."""
+    return [
+        "",
+        "OUTPUT FORMAT:",
+        "Return ONLY a valid YAML Ansible playbook. Do not include any",
+        "   explanation, markdown formatting, or code blocks. The output should",
+        "   be pure YAML that can be directly used as an Ansible playbook.",
+        "",
+        "CRITICAL YAML SYNTAX RULES:",
+        "- Use block mapping style (one key per line) NOT flow mapping style",
+        "- NEVER use { } for mappings with conditionals or complex expressions",
+        "- Correct: Use multi-line format:",
+        "    - name: Include role conditionally",
+        "      ansible.builtin.import_role:",
+        "        name: my_role",
+        "      when: condition_here",
+        "- WRONG: { role: my_role, when: condition }  # This is INVALID",
+        "",
+        "The playbook should include:",
+        "- A proper name",
+        "- Appropriate hosts (default to 'all')",
+        "- Variables section if needed",
+        "- Tasks section with all converted resources",
+        "- Handlers section if notifications are used",
+        "- Any necessary pre_tasks or post_tasks",
+        "",
+        "Example structure:",
+        "---",
+        "- name: Convert of <recipe_name>",
+        "  hosts: all",
+        "  become: true",
+        "  vars:",
+        "    # Variables here",
+        "  tasks:",
+        "    # Tasks here",
+        "  handlers:",
+        "    # Handlers here",
+        "",
+        "Focus on creating a functional, well-structured Ansible playbook that",
+        "achieves the same outcome as the Chef recipe.",
+    ]
 
 
 def _clean_ai_playbook_response(ai_response: str) -> str:
@@ -507,6 +675,7 @@ def _run_ansible_lint(playbook_content: str) -> str | None:
     if shutil.which("ansible-lint") is None:
         return None
 
+    tmp_path = None
     try:
         with tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False) as tmp:
             tmp.write(playbook_content)
@@ -528,7 +697,7 @@ def _run_ansible_lint(playbook_content: str) -> str | None:
     except Exception:
         return None
     finally:
-        if "tmp_path" in locals() and Path(tmp_path).exists():
+        if tmp_path is not None and Path(tmp_path).exists():
             Path(tmp_path).unlink()
 
 

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