mcp-souschef 2.2.0__py3-none-any.whl → 2.8.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
@@ -41,6 +46,51 @@ def _parse_properties(properties_str: str) -> dict[str, Any]:
             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(
     resource_type: str, resource_name: str, action: str = "create", properties: str = ""
 ) -> str:
@@ -188,6 +238,22 @@ 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.
+    """
+    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"}
+
+
 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 +275,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 +296,23 @@ 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"]
+
+    # 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 +325,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 +355,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 +393,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 +415,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/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

souschef/core/path_utils.py

@@ -7,10 +7,8 @@ def _normalize_path(path_str: str) -> Path:
     """
     Normalize a file path for safe filesystem operations.
 
-    This function resolves relative paths and symlinks to absolute paths,
-    preventing path traversal attacks (CWE-23). Note: This MCP server
-    intentionally allows full filesystem access as it runs in the user's
-    local environment with their permissions.
+    This function validates input and resolves relative paths and symlinks
+    to absolute paths, preventing path traversal attacks (CWE-23).
 
     Args:
         path_str: Path string to normalize.
@@ -19,17 +17,22 @@ def _normalize_path(path_str: str) -> Path:
         Resolved absolute Path object.
 
     Raises:
-        ValueError: If the path contains null bytes or is invalid.
+        ValueError: If the path contains null bytes, traversal attempts, or is invalid.
 
     """
+    if not isinstance(path_str, str):
+        raise ValueError(f"Path must be a string, got {type(path_str)}")
+
+    # Reject paths with null bytes
     if "\x00" in path_str:
         raise ValueError(f"Path contains null bytes: {path_str!r}")
 
+    # Reject paths with obvious directory traversal attempts
+    if ".." in path_str:
+        raise ValueError(f"Path contains directory traversal: {path_str!r}")
+
     try:
-        # Resolve to absolute path, removing .., ., and resolving symlinks
-        # This is the path normalization function itself that validates input
-        # lgtm[py/path-injection]
-        # codeql[py/path-injection]
+        # Resolve to absolute path, removing ., and resolving symlinks
         return Path(path_str).resolve()
     except (OSError, RuntimeError) as e:
         raise ValueError(f"Invalid path {path_str}: {e}") from e

souschef/core/validation.py

@@ -234,10 +234,43 @@ class ValidationEngine:
         if "import pytest" in result:
             # Testinfra format
             self._validate_python_syntax(result)
-        elif "---" in result:
-            # Ansible assert format
+        elif "require 'serverspec'" in result:
+            # ServerSpec format (Ruby)
+            self._validate_ruby_syntax(result)
+        elif "---" in result or ("package:" in result and "service:" in result):
+            # Ansible assert or Goss YAML format
             self._validate_yaml_syntax(result)
 
+    def _validate_ruby_syntax(self, ruby_content: str) -> None:
+        """
+        Validate Ruby syntax.
+
+        Args:
+            ruby_content: Ruby content to validate.
+
+        """
+        # Basic Ruby syntax checks
+        if not ruby_content.strip():
+            self._add_result(
+                ValidationLevel.ERROR,
+                ValidationCategory.SYNTAX,
+                "Empty Ruby content",
+                suggestion="Ensure the conversion produced valid Ruby code",
+            )
+            return
+
+        # Check for balanced blocks (describe/do/end)
+        do_count = len(re.findall(r"\bdo\b", ruby_content))
+        end_count = len(re.findall(r"\bend\b", ruby_content))
+
+        if do_count != end_count:
+            self._add_result(
+                ValidationLevel.ERROR,
+                ValidationCategory.SYNTAX,
+                f"Unbalanced Ruby blocks: {do_count} 'do' but {end_count} 'end'",
+                suggestion="Check that all 'do' blocks have matching 'end' keywords",
+            )
+
     def _validate_yaml_syntax(self, yaml_content: str) -> None:
         """
         Validate YAML syntax.

souschef/deployment.py

@@ -51,7 +51,7 @@ def generate_awx_job_template_from_cookbook(
             )
 
         cookbook = validate_cookbook_structure(cookbook_path)
-        cookbook_analysis = _analyze_cookbook_for_awx(cookbook, cookbook_name)
+        cookbook_analysis = _analyse_cookbook_for_awx(cookbook, cookbook_name)
         job_template = _generate_awx_job_template(
             cookbook_analysis, cookbook_name, target_environment, include_survey
         )
@@ -184,7 +184,7 @@ def generate_awx_project_from_cookbooks(
         )
 
         # Analyze all cookbooks
-        cookbooks_analysis = _analyze_cookbooks_directory(cookbooks_path)
+        cookbooks_analysis = _analyse_cookbooks_directory(cookbooks_path)
 
         # Generate project structure
         project_config = _generate_awx_project_config(project_name, scm_type, scm_url)
@@ -329,7 +329,7 @@ def convert_chef_deployment_to_ansible_strategy(
             )
 
         # Analyze Chef deployment pattern
-        pattern_analysis = _analyze_chef_deployment_pattern(cookbook)
+        pattern_analysis = _analyse_chef_deployment_pattern(cookbook)
 
         # Determine best strategy if auto-detect
         if deployment_pattern == "auto":
@@ -474,14 +474,16 @@ def _validate_canary_inputs(
             raise ValueError("Steps must be between 1 and 100")
         if steps != sorted(steps):
             return None, (
-                f"Error: Rollout steps must be in ascending order: {rollout_steps}\n\n"
+                "Error: Rollout steps must be in ascending order: "
+                f"{rollout_steps}\n\n"
                 "Suggestion: Use format like '10,25,50,100'"
             )
         return steps, None
     except ValueError as e:
-        return None, (
+        return (
+            None,
             f"Error: Invalid rollout steps '{rollout_steps}': {e}\n\n"
-            "Suggestion: Use comma-separated percentages like '10,25,50,100'"
+            "Suggestion: Use comma-separated percentages like '10,25,50,100'",
         )
 
 
@@ -624,11 +626,11 @@ def generate_canary_deployment_strategy(
         )
 
 
-def analyze_chef_application_patterns(
+def analyse_chef_application_patterns(
     cookbook_path: str, application_type: str = "web_application"
 ) -> str:
     """
-    Analyze cookbook deployment patterns and recommend Ansible strategies.
+    Analyse cookbook deployment patterns and recommend Ansible strategies.
 
     Detects blue/green, canary, rolling, or custom deployment approaches.
     Application type helps tune recommendations for web/database/service workloads.
@@ -645,7 +647,7 @@ def analyze_chef_application_patterns(
             )
 
         # Analyze cookbook for application patterns
-        analysis = _analyze_application_cookbook(cookbook, application_type)
+        analysis = _analyse_application_cookbook(cookbook, application_type)
 
         return f"""# Chef Application Patterns Analysis
 # Cookbook: {cookbook.name}
@@ -683,9 +685,9 @@ def analyze_chef_application_patterns(
 # AWX Helper Functions
 
 
-def _analyze_recipes(cookbook_path: Path) -> list[dict[str, Any]]:
+def _analyse_recipes(cookbook_path: Path) -> list[dict[str, Any]]:
     """
-    Analyze recipes directory for AWX job steps.
+    Analyse recipes directory for AWX job steps.
 
     Args:
         cookbook_path: Path to cookbook root
@@ -708,11 +710,11 @@ def _analyze_recipes(cookbook_path: Path) -> list[dict[str, Any]]:
     return recipes
 
 
-def _analyze_attributes_for_survey(
+def _analyse_attributes_for_survey(
     cookbook_path: Path,
 ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
     """
-    Analyze attributes directory for survey field generation.
+    Analyse attributes directory for survey field generation.
 
     Args:
         cookbook_path: Path to cookbook root
@@ -746,7 +748,7 @@ def _analyze_attributes_for_survey(
     return attributes, survey_fields
 
 
-def _analyze_metadata_dependencies(cookbook_path: Path) -> list[str]:
+def _analyse_metadata_dependencies(cookbook_path: Path) -> list[str]:
     """
     Extract cookbook dependencies from metadata.
 
@@ -793,9 +795,9 @@ def _collect_static_files(cookbook_path: Path) -> tuple[list[str], list[str]]:
     return templates, files
 
 
-def _analyze_cookbook_for_awx(cookbook_path: Path, cookbook_name: str) -> dict:
+def _analyse_cookbook_for_awx(cookbook_path: Path, cookbook_name: str) -> dict:
     """
-    Analyze Chef cookbook structure for AWX job template generation.
+    Analyse Chef cookbook structure for AWX job template generation.
 
     Orchestrates multiple analysis helpers to build comprehensive cookbook metadata.
 
@@ -808,9 +810,9 @@ def _analyze_cookbook_for_awx(cookbook_path: Path, cookbook_name: str) -> dict:
 
     """
     # Analyze each dimension independently
-    recipes = _analyze_recipes(cookbook_path)
-    attributes, survey_fields = _analyze_attributes_for_survey(cookbook_path)
-    dependencies = _analyze_metadata_dependencies(cookbook_path)
+    recipes = _analyse_recipes(cookbook_path)
+    attributes, survey_fields = _analyse_attributes_for_survey(cookbook_path)
+    dependencies = _analyse_metadata_dependencies(cookbook_path)
     templates, files = _collect_static_files(cookbook_path)
 
     # Assemble complete analysis
@@ -1153,8 +1155,8 @@ def _generate_survey_fields_from_attributes(attributes: dict) -> list:
     return survey_fields
 
 
-def _analyze_cookbooks_directory(cookbooks_path: Path) -> dict:
-    """Analyze entire cookbooks directory structure."""
+def _analyse_cookbooks_directory(cookbooks_path: Path) -> dict:
+    """Analyse entire cookbooks directory structure."""
     analysis: dict[str, Any] = {
         "total_cookbooks": 0,
         "cookbooks": {},
@@ -1170,7 +1172,7 @@ def _analyze_cookbooks_directory(cookbooks_path: Path) -> dict:
         cookbook_name = cookbook_dir.name
         analysis["total_cookbooks"] += 1
 
-        cookbook_analysis = _analyze_cookbook_for_awx(cookbook_dir, cookbook_name)
+        cookbook_analysis = _analyse_cookbook_for_awx(cookbook_dir, cookbook_name)
         analysis["cookbooks"][cookbook_name] = cookbook_analysis
 
         # Aggregate stats
@@ -1184,8 +1186,8 @@ def _analyze_cookbooks_directory(cookbooks_path: Path) -> dict:
 # Deployment Strategy Helper Functions
 
 
-def _analyze_chef_deployment_pattern(cookbook_path: Path) -> dict:
-    """Analyze Chef cookbook for deployment patterns."""
+def _analyse_chef_deployment_pattern(cookbook_path: Path) -> dict:
+    """Analyse Chef cookbook for deployment patterns."""
     analysis: dict[str, Any] = {
         "deployment_steps": [],
         "health_checks": [],
@@ -1503,8 +1505,8 @@ def _assess_complexity_from_resource_count(resource_count: int) -> tuple[str, st
     return "medium", "2-3 weeks", "medium"
 
 
-def _analyze_application_cookbook(cookbook_path: Path, app_type: str) -> dict:
-    """Analyze Chef cookbook for application deployment patterns."""
+def _analyse_application_cookbook(cookbook_path: Path, app_type: str) -> dict:
+    """Analyse Chef cookbook for application deployment patterns."""
     analysis: dict[str, Any] = {
         "application_type": app_type,
         "deployment_patterns": [],
@@ -1648,7 +1650,7 @@ def _format_deployment_patterns(analysis: dict) -> str:
 
 def _format_chef_resources_analysis(analysis: dict) -> str:
     """Format Chef resources analysis."""
-    # Check for new format first (from _analyze_application_cookbook)
+    # Check for new format first (from _analyse_application_cookbook)
     resources = analysis.get("resources", [])
     if resources:
         # Count resource types

souschef/filesystem/operations.py

@@ -1,7 +1,5 @@
 """Filesystem operations for Chef cookbook exploration."""
 
-from mcp.server.fastmcp import FastMCP
-
 from souschef.core.constants import (
     ERROR_FILE_NOT_FOUND,
     ERROR_IS_DIRECTORY,
@@ -9,11 +7,7 @@ from souschef.core.constants import (
 )
 from souschef.core.path_utils import _normalize_path
 
-# Get MCP instance to register tools
-mcp = FastMCP("souschef")
-
 
-@mcp.tool()
 def list_directory(path: str) -> list[str] | str:
     """
     List the contents of a directory.
@@ -40,7 +34,6 @@ def list_directory(path: str) -> list[str] | str:
         return f"An error occurred: {e}"
 
 
-@mcp.tool()
 def read_file(path: str) -> str:
     """
     Read the contents of a file.

souschef/parsers/__init__.py

@@ -13,7 +13,11 @@ from souschef.parsers.inspec import (
     generate_inspec_from_chef,
     parse_inspec_profile,
 )
-from souschef.parsers.metadata import list_cookbook_structure, read_cookbook_metadata
+from souschef.parsers.metadata import (
+    list_cookbook_structure,
+    parse_cookbook_metadata,
+    read_cookbook_metadata,
+)
 from souschef.parsers.recipe import parse_recipe
 from souschef.parsers.resource import parse_custom_resource
 from souschef.parsers.template import parse_template
@@ -24,6 +28,7 @@ __all__ = [
     "parse_attributes",
     "parse_custom_resource",
     "read_cookbook_metadata",
+    "parse_cookbook_metadata",
     "list_cookbook_structure",
     "parse_inspec_profile",
     "convert_inspec_to_test",