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

souschef/server.py

@@ -21,12 +21,16 @@ from souschef.assessment import (
 from souschef.assessment import (
     generate_migration_report as _generate_migration_report,
 )
+from souschef.assessment import (
+    parse_chef_migration_assessment as _parse_chef_migration_assessment,
+)
 from souschef.assessment import (
     validate_conversion as _validate_conversion,
 )
 
 # Import extracted modules
 # Import private helper functions still used in server.py
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.converters.habitat import (  # noqa: F401
     _add_service_build,
     _add_service_dependencies,
@@ -48,6 +52,7 @@ from souschef.converters.habitat import (
 )
 
 # Re-exports of playbook internal functions for backward compatibility (tests)
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.converters.playbook import (  # noqa: F401
     _add_general_recommendations,
     _convert_chef_block_to_ansible,
@@ -82,9 +87,8 @@ from souschef.converters.playbook import (
 from souschef.converters.playbook import (
     generate_dynamic_inventory_script as _generate_dynamic_inventory_script,
 )
-from souschef.converters.playbook import (
-    generate_playbook_from_recipe as _generate_playbook_from_recipe,
-)
+
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.converters.resource import (  # noqa: F401
     _convert_chef_resource_to_ansible,
     _format_ansible_task,
@@ -97,6 +101,7 @@ from souschef.converters.resource import (
 
 # Re-exports for backward compatibility (used by tests) - DO NOT REMOVE
 # These imports are intentionally exposed for external test access
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.core.constants import (  # noqa: F401
     ACTION_TO_STATE,
     ANSIBLE_SERVICE_MODULE,
@@ -106,16 +111,21 @@ from souschef.core.constants import (  # noqa: F401
 )
 
 # Import core utilities
+from souschef.core.errors import format_error_with_context
+
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.core.path_utils import _normalize_path, _safe_join  # noqa: F401
 
 # Re-exports for backward compatibility (used by tests) - DO NOT REMOVE
 # These imports are intentionally exposed for external test access
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.core.ruby_utils import (  # noqa: F401
     _normalize_ruby_value,
 )
 
 # Re-exports for backward compatibility (used by tests) - DO NOT REMOVE
 # These imports are intentionally exposed for external test access
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.core.validation import (  # noqa: F401
     ValidationCategory,
     ValidationEngine,
@@ -127,6 +137,7 @@ from souschef.core.validation import (  # noqa: F401
 # Re-exports of deployment internal functions for backward compatibility (tests)
 # Public re-exports of deployment functions for test backward compatibility
 # Note: MCP tool wrappers exist for some of these, but tests import directly
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.deployment import (  # noqa: F401
     _analyze_cookbook_for_awx,
     _analyze_cookbooks_directory,
@@ -180,6 +191,8 @@ from souschef.deployment import (
 # Import filesystem operations
 from souschef.filesystem import list_directory as _list_directory
 from souschef.filesystem import read_file as _read_file
+
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.attributes import (  # noqa: F401
     _extract_attributes,
     _format_attributes,
@@ -190,6 +203,8 @@ from souschef.parsers.attributes import (  # noqa: F401
 
 # Import parser functions
 from souschef.parsers.attributes import parse_attributes as _parse_attributes
+
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.habitat import (  # noqa: F401
     _extract_plan_array,
     _extract_plan_exports,
@@ -202,13 +217,24 @@ from souschef.parsers.habitat import (  # noqa: F401
 from souschef.parsers.habitat import parse_habitat_plan as _parse_habitat_plan
 
 # Re-export InSpec internal functions for backward compatibility (tests)
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.inspec import (  # noqa: F401
     _convert_inspec_to_ansible_assert,
+    _convert_inspec_to_goss,
+    _convert_inspec_to_serverspec,
     _convert_inspec_to_testinfra,
     _extract_inspec_describe_blocks,
     _generate_inspec_from_resource,
     _parse_inspec_control,
 )
+from souschef.parsers.inspec import (
+    convert_inspec_to_test as _convert_inspec_test,
+)
+from souschef.parsers.inspec import (
+    parse_inspec_profile as _parse_inspec,
+)
+
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.metadata import (  # noqa: F401
     _extract_metadata,
     _format_cookbook_structure,
@@ -217,18 +243,27 @@ from souschef.parsers.metadata import (  # noqa: F401
 from souschef.parsers.metadata import (
     list_cookbook_structure as _list_cookbook_structure,
 )
+from souschef.parsers.metadata import (
+    parse_cookbook_metadata as _parse_cookbook_metadata,
+)
 from souschef.parsers.metadata import read_cookbook_metadata as _read_cookbook_metadata
+
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.recipe import (  # noqa: F401
     _extract_conditionals,
     _extract_resources,
     _format_resources,
 )
 from souschef.parsers.recipe import parse_recipe as _parse_recipe
+
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.resource import (  # noqa: F401
     _extract_resource_actions,
     _extract_resource_properties,
 )
 from souschef.parsers.resource import parse_custom_resource as _parse_custom_resource
+
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.template import (  # noqa: F401
     _convert_erb_to_jinja2,
     _extract_code_block_variables,
@@ -330,6 +365,21 @@ def read_cookbook_metadata(path: str) -> str:
     return _read_cookbook_metadata(path)
 
 
+@mcp.tool()
+def parse_cookbook_metadata(path: str) -> dict[str, str | list[str]]:
+    """
+    Parse Chef cookbook metadata.rb file and return as dictionary.
+
+    Args:
+        path: Path to the metadata.rb file.
+
+    Returns:
+        Dictionary containing extracted metadata fields.
+
+    """
+    return _parse_cookbook_metadata(path)
+
+
 @mcp.tool()
 def parse_recipe(path: str) -> str:
     """
@@ -513,6 +563,7 @@ def _parse_controls_from_file(profile_path: Path) -> list[dict[str, Any]]:
         raise RuntimeError(f"Error reading file: {e}") from e
 
 
+@mcp.tool()
 def parse_inspec_profile(path: str) -> str:
     """
     Parse an InSpec profile and extract controls.
@@ -524,93 +575,23 @@ def parse_inspec_profile(path: str) -> str:
         JSON string with parsed controls, or error message.
 
     """
-    try:
-        profile_path = _normalize_path(path)
-
-        if not profile_path.exists():
-            return f"Error: Path does not exist: {path}"
-
-        if profile_path.is_dir():
-            controls = _parse_controls_from_directory(profile_path)
-        elif profile_path.is_file():
-            controls = _parse_controls_from_file(profile_path)
-        else:
-            return f"Error: Invalid path type: {path}"
-
-        return json.dumps(
-            {
-                "profile_path": str(profile_path),
-                "controls_count": len(controls),
-                "controls": controls,
-            },
-            indent=2,
-        )
-
-    except (FileNotFoundError, RuntimeError) as e:
-        return f"Error: {e}"
-    except Exception as e:
-        return f"An error occurred while parsing InSpec profile: {e}"
+    return _parse_inspec(path)
 
 
 @mcp.tool()
 def convert_inspec_to_test(inspec_path: str, output_format: str = "testinfra") -> str:
     """
-    Convert InSpec controls to Ansible test format.
+    Convert InSpec controls to test framework format.
 
     Args:
         inspec_path: Path to InSpec profile or control file.
-        output_format: Output format ('testinfra' or 'ansible_assert').
+        output_format: Output format ('testinfra', 'ansible_assert', 'serverspec', or 'goss').
 
     Returns:
         Converted test code or error message.
 
     """
-    try:
-        # First parse the InSpec profile
-        parse_result = parse_inspec_profile(inspec_path)
-
-        # Check if parsing failed
-        if parse_result.startswith(ERROR_PREFIX):
-            return parse_result
-
-        # Parse JSON result
-        profile_data = json.loads(parse_result)
-        controls = profile_data["controls"]
-
-        if not controls:
-            return "Error: No controls found in InSpec profile"
-
-        # Convert each control
-        converted_tests = []
-
-        if output_format == "testinfra":
-            converted_tests.append("import pytest")
-            converted_tests.append("")
-            converted_tests.append("")
-            for control in controls:
-                test_code = _convert_inspec_to_testinfra(control)
-                converted_tests.append(test_code)
-
-        elif output_format == "ansible_assert":
-            converted_tests.append("---")
-            converted_tests.append("# Validation tasks converted from InSpec")
-            converted_tests.append("")
-            for control in controls:
-                assert_code = _convert_inspec_to_ansible_assert(control)
-                converted_tests.append(assert_code)
-                converted_tests.append("")
-
-        else:
-            error_msg = (
-                f"Error: Unsupported format '{output_format}'. "
-                "Use 'testinfra' or 'ansible_assert'"
-            )
-            return error_msg
-
-        return "\n".join(converted_tests)
-
-    except Exception as e:
-        return f"An error occurred while converting InSpec: {e}"
+    return _convert_inspec_test(inspec_path, output_format)
 
 
 def _extract_resources_from_parse_result(parse_result: str) -> list[dict[str, Any]]:
@@ -696,7 +677,9 @@ def generate_inspec_from_recipe(recipe_path: str) -> str:
         return "\n".join(controls)
 
     except Exception as e:
-        return f"An error occurred while generating InSpec controls: {e}"
+        return format_error_with_context(
+            e, "generating InSpec controls from recipe", recipe_path
+        )
 
 
 @mcp.tool()
@@ -724,11 +707,34 @@ def convert_chef_databag_to_vars(
     try:
         import yaml
 
+        # Validate inputs
+        if not databag_content or not databag_content.strip():
+            return (
+                "Error: Databag content cannot be empty\n\n"
+                "Suggestion: Provide valid JSON content from a Chef data bag"
+            )
+
+        if not databag_name or not databag_name.strip():
+            return (
+                "Error: Databag name cannot be empty\n\n"
+                "Suggestion: Provide a valid data bag name"
+            )
+
+        valid_scopes = ["group_vars", "host_vars", "playbook"]
+        if target_scope not in valid_scopes:
+            return (
+                f"Error: Invalid target scope '{target_scope}'\n\n"
+                f"Suggestion: Use one of {', '.join(valid_scopes)}"
+            )
+
         # Parse the data bag content
         try:
             parsed_databag = json.loads(databag_content)
         except json.JSONDecodeError as e:
-            return f"Error: Invalid JSON format in data bag: {e}"
+            return (
+                f"Error: Invalid JSON format in data bag: {e}\n\n"
+                "Suggestion: Ensure the databag content is valid JSON"
+            )
 
         # Convert to Ansible variables format
         ansible_vars = _convert_databag_to_ansible_vars(
@@ -763,14 +769,95 @@ def convert_chef_databag_to_vars(
 {yaml_content.rstrip()}
 """
     except Exception as e:
-        return f"Error converting data bag to Ansible variables: {e}"
+        return format_error_with_context(
+            e, f"converting data bag '{databag_name}' to Ansible variables"
+        )
 
 
 @mcp.tool()
+def _validate_databags_directory(
+    databags_directory: str,
+) -> tuple[Path | None, str | None]:
+    """
+    Validate databags directory input.
+
+    Args:
+        databags_directory: Path to the data bags directory.
+
+    Returns:
+        Tuple of (normalized_path, error_message).
+        If validation succeeds: (Path, None)
+        If validation fails: (None, error_message)
+
+    """
+    if not databags_directory or not databags_directory.strip():
+        return None, (
+            "Error: Databags directory path cannot be empty\n\n"
+            "Suggestion: Provide the path to your Chef data_bags directory"
+        )
+
+    databags_path = _normalize_path(databags_directory)
+    if not databags_path.exists():
+        return None, (
+            f"Error: Data bags directory not found: {databags_directory}\n\n"
+            "Suggestion: Check that the path is correct and the directory exists"
+        )
+
+    if not databags_path.is_dir():
+        return None, (
+            f"Error: Path is not a directory: {databags_directory}\n\n"
+            "Suggestion: Provide a path to the data_bags directory"
+        )
+
+    return databags_path, None
+
+
+def _convert_databag_item(item_file, databag_name: str, output_directory: str) -> dict:
+    """Convert a single databag item file to Ansible format."""
+    item_name = item_file.stem
+
+    try:
+        with item_file.open() as f:
+            content = f.read()
+
+        # Detect if encrypted
+        is_encrypted = _detect_encrypted_databag(content)
+
+        # Convert to Ansible format
+        result = convert_chef_databag_to_vars(
+            content, databag_name, item_name, is_encrypted, output_directory
+        )
+
+        vault_suffix = "_vault" if is_encrypted else ""
+        target_file = f"{output_directory}/{databag_name}{vault_suffix}.yml"
+
+        return {
+            "databag": databag_name,
+            "item": item_name,
+            "encrypted": is_encrypted,
+            "target_file": target_file,
+            "content": result,
+        }
+
+    except Exception as e:
+        return {"databag": databag_name, "item": item_name, "error": str(e)}
+
+
+def _process_databag_directory(databag_dir, output_directory: str) -> list[dict]:
+    """Process all items in a single databag directory."""
+    results = []
+    databag_name = databag_dir.name
+
+    for item_file in databag_dir.glob("*.json"):
+        result = _convert_databag_item(item_file, databag_name, output_directory)
+        results.append(result)
+
+    return results
+
+
 def generate_ansible_vault_from_databags(
     databags_directory: str,
     output_directory: str = "group_vars",
-    encryption_key_hint: str = "",
 ) -> str:
     """
     Generate Ansible Vault files from Chef data bags directory.
@@ -778,16 +865,21 @@ def generate_ansible_vault_from_databags(
     Args:
         databags_directory: Path to Chef data_bags directory
         output_directory: Target directory for Ansible variables (group_vars/host_vars)
-        encryption_key_hint: Hint for identifying encrypted data bags
 
     Returns:
         Summary of converted data bags and instructions
 
     """
     try:
-        databags_path = _normalize_path(databags_directory)
-        if not databags_path.exists():
-            return f"Error: Data bags directory not found: {databags_directory}"
+        # Validate inputs
+        databags_path, error = _validate_databags_directory(databags_directory)
+        if error:
+            assert isinstance(error, str), "error must be string when present"
+            return error
+
+        assert databags_path is not None, (
+            "databags_path must be non-None after successful validation"
+        )
 
         conversion_results = []
 
@@ -796,40 +888,8 @@ def generate_ansible_vault_from_databags(
             if not databag_dir.is_dir():
                 continue
 
-            databag_name = databag_dir.name
-
-            # Process each item in the data bag
-            for item_file in databag_dir.glob("*.json"):
-                item_name = item_file.stem
-
-                try:
-                    with item_file.open() as f:
-                        content = f.read()
-
-                    # Detect if encrypted (Chef encrypted data bags have specific structure)
-                    is_encrypted = _detect_encrypted_databag(content)
-
-                    # Convert to Ansible format
-                    result = convert_chef_databag_to_vars(
-                        content, databag_name, item_name, is_encrypted, output_directory
-                    )
-
-                    vault_suffix = "_vault" if is_encrypted else ""
-                    target_file = f"{output_directory}/{databag_name}{vault_suffix}.yml"
-                    conversion_results.append(
-                        {
-                            "databag": databag_name,
-                            "item": item_name,
-                            "encrypted": is_encrypted,
-                            "target_file": target_file,
-                            "content": result,
-                        }
-                    )
-
-                except Exception as e:
-                    conversion_results.append(
-                        {"databag": databag_name, "item": item_name, "error": str(e)}
-                    )
+            results = _process_databag_directory(databag_dir, output_directory)
+            conversion_results.extend(results)
 
         # Generate summary and file structure
         return _generate_databag_conversion_summary(
@@ -837,7 +897,9 @@ def generate_ansible_vault_from_databags(
         )
 
     except Exception as e:
-        return f"Error processing data bags directory: {e}"
+        return format_error_with_context(
+            e, "processing data bags directory", databags_directory
+        )
 
 
 @mcp.tool()
@@ -891,7 +953,7 @@ def analyze_chef_databag_usage(cookbook_path: str, databags_path: str = "") -> s
 4. Encrypt sensitive data with ansible-vault
 """
     except Exception as e:
-        return f"Data bag parsing failed: {e}"
+        return format_error_with_context(e, "analyzing data bag usage", cookbook_path)
 
 
 @mcp.tool()
@@ -936,7 +998,9 @@ def convert_chef_environment_to_inventory_group(
 # {environment_name}
 """
     except Exception as e:
-        return f"Environment conversion failed: {e}"
+        return format_error_with_context(
+            e, "converting Chef environment to inventory group", environment_name
+        )
 
 
 @mcp.tool()
@@ -994,7 +1058,9 @@ def generate_inventory_from_chef_environments(
         )
 
     except Exception as e:
-        return f"Error generating inventory from Chef environments: {e}"
+        return format_error_with_context(
+            e, "generating inventory from Chef environments", environments_directory
+        )
 
 
 @mcp.tool()
@@ -1053,7 +1119,9 @@ def analyze_chef_environment_usage(
 5. Test environment-specific deployments with new inventory structure
 """
     except Exception as e:
-        return f"Error analyzing Chef environment usage: {e}"
+        return format_error_with_context(
+            e, "analyzing Chef environment usage", cookbook_path
+        )
 
 
 def _parse_chef_environment_content(content: str) -> dict:
@@ -1094,6 +1162,183 @@ def _parse_chef_environment_content(content: str) -> dict:
     return env_data
 
 
+def _convert_ruby_literal(value: str) -> Any:
+    """
+    Convert Ruby literal values to equivalent Python types.
+
+    This function handles the conversion of Ruby's basic literal values
+    to their Python equivalents during Chef environment parsing.
+
+    Args:
+        value: String representation of a Ruby literal value.
+
+    Returns:
+        The converted Python value:
+        - "true" -> True (bool)
+        - "false" -> False (bool)
+        - "nil" -> None
+        - Integer strings -> int (e.g., "42" -> 42)
+        - Float strings -> float (e.g., "3.14" -> 3.14, "1e10" -> 10000000000.0)
+        - Unrecognized values -> original string unchanged
+
+    Examples:
+        >>> _convert_ruby_literal("true")
+        True
+        >>> _convert_ruby_literal("42")
+        42
+        >>> _convert_ruby_literal("3.14")
+        3.14
+        >>> _convert_ruby_literal("nil")
+        None
+        >>> _convert_ruby_literal("some_string")
+        'some_string'
+
+    """
+    # Handle boolean and nil values
+    literal_map = {
+        "true": True,
+        "false": False,
+        "nil": None,
+    }
+
+    if value in literal_map:
+        return literal_map[value]
+
+    # Handle numeric values
+    try:
+        # Try integer first
+        if "." not in value and "e" not in value.lower():
+            return int(value)
+        else:
+            return float(value)
+    except ValueError:
+        pass
+
+    # Return as string if no conversion applies
+    return value
+
+
+def _parse_quoted_key(content: str, i: int) -> tuple[str, int]:
+    """Parse a quoted key and return (key, new_index)."""
+    if content[i] not in "'\"":
+        raise ValueError("Expected quote at start of key")
+
+    quote = content[i]
+    i += 1
+    key_start = i
+    while i < len(content) and content[i] != quote:
+        i += 1
+    key = content[key_start:i]
+    i += 1  # skip closing quote
+    return key, i
+
+
+def _parse_nested_hash(content: str, i: int) -> tuple[dict, int]:
+    """Parse a nested hash and return (parsed_dict, new_index)."""
+    if content[i] != "{":
+        raise ValueError("Expected opening brace for nested hash")
+
+    brace_count = 1
+    start = i
+    i += 1
+    while i < len(content) and brace_count > 0:
+        if content[i] == "{":
+            brace_count += 1
+        elif content[i] == "}":
+            brace_count -= 1
+        i += 1
+
+    nested_content = content[start + 1 : i - 1]  # exclude braces
+    return parse_ruby_hash(nested_content), i
+
+
+def _parse_simple_value(content: str, i: int) -> tuple[str, int]:
+    """Parse a simple value and return (value, new_index)."""
+    value_start = i
+    while i < len(content) and content[i] not in ",}":
+        i += 1
+    value = content[value_start:i].strip()
+    # Remove quotes if present
+    if (value.startswith("'") and value.endswith("'")) or (
+        value.startswith('"') and value.endswith('"')
+    ):
+        value = value[1:-1]
+    else:
+        # Convert Ruby literals to Python types
+        value = _convert_ruby_literal(value)
+    return value, i
+
+
+def _skip_to_next_item(content: str, i: int) -> int:
+    """Skip to the next item, handling delimiters."""
+    while i < len(content) and content[i] not in ",}":
+        i += 1
+    if i < len(content) and (content[i] == "," or content[i] == "}"):
+        i += 1
+    return i
+
+
+def parse_ruby_hash(content: str) -> dict:
+    """Parse Ruby hash syntax recursively."""
+    result = {}
+
+    # Simple recursive parser for Ruby hash syntax
+    # This handles nested braces by counting them
+    i = 0
+    while i < len(content):
+        # Skip whitespace
+        i = _skip_whitespace(content, i)
+        if i >= len(content):
+            break
+
+        # Parse key-value pair
+        key, value, i = _parse_key_value_pair(content, i)
+        if key is not None:
+            result[key] = value
+
+        # Skip to next item
+        i = _skip_to_next_item(content, i)
+
+    return result
+
+
+def _skip_whitespace(content: str, i: int) -> int:
+    """Skip whitespace characters and return new index."""
+    while i < len(content) and content[i].isspace():
+        i += 1
+    return i
+
+
+def _parse_key_value_pair(content: str, i: int) -> tuple[str | None, Any, int]:
+    """Parse a single key => value pair and return (key, value, new_index)."""
+    # Look for key => value patterns
+    if content[i] in "'\"":
+        # Parse quoted key
+        key, i = _parse_quoted_key(content, i)
+
+        # Skip whitespace and =>
+        i = _skip_whitespace_and_arrows(content, i)
+
+        value: Any
+        if i < len(content) and content[i] == "{":
+            # Nested hash
+            value, i = _parse_nested_hash(content, i)
+        else:
+            # Simple value
+            value, i = _parse_simple_value(content, i)
+
+        return key, value, i
+
+    return None, None, i
+
+
+def _skip_whitespace_and_arrows(content: str, i: int) -> int:
+    """Skip whitespace and => symbols."""
+    while i < len(content) and (content[i].isspace() or content[i] in "=>"):
+        i += 1
+    return i
+
+
 def _extract_attributes_block(content: str, block_type: str) -> dict:
     """Extract attribute blocks from Chef environment content."""
     # Find the block start
@@ -1105,37 +1350,7 @@ def _extract_attributes_block(content: str, block_type: str) -> dict:
 
     block_content = match.group(1).strip()
 
-    # Simple parsing of Ruby hash-like structure
-    # Ruby attribute hashes use => syntax, which we convert to Python dict
-    # This is intentionally simple - complex Chef DSL needs full Ruby parser
-    attributes = {}
-
-    # Parse simple key-value pairs like 'port' => '8080'
-    key_value_pattern = (
-        r"['\"]([^'\"]{0,100})['\"][\s:]*=>[\s:]*['\"]([^'\"]{0,200})['\"]"
-    )
-    for match in re.finditer(key_value_pattern, block_content):
-        attr_key = match.group(1)
-        attr_value = match.group(2)
-        attributes[attr_key] = attr_value
-
-    # Parse nested structures (basic support)
-    nested_pattern = (
-        r"['\"](([^'\"\n]{0,100}))['\"](\\s|:)*=>(\\s|:)*\\{([^}]{0,500})\\}"
-    )
-    for match in re.finditer(nested_pattern, block_content):
-        key = match.group(1)
-        nested_content = match.group(5)
-        nested_attrs = {}
-
-        for nested_match in re.finditer(key_value_pattern, nested_content):
-            nested_key = nested_match.group(1)
-            nested_value = nested_match.group(2)
-            nested_attrs[nested_key] = nested_value
-
-        if nested_attrs:
-            attributes[key] = nested_attrs
-
+    attributes = parse_ruby_hash(block_content)
     return attributes
 
 
@@ -1196,18 +1411,27 @@ def _generate_inventory_group_from_environment(
     return yaml.dump(group_vars, default_flow_style=False, indent=2)
 
 
-def _generate_complete_inventory_from_environments(
-    environments: dict, results: list, output_format: str
-) -> str:
-    """Generate complete Ansible inventory from multiple Chef environments."""
-    import yaml
+def _build_conversion_summary(results: list) -> str:
+    """
+    Build summary of environment conversion results.
+
+    Args:
+        results: List of conversion result dicts
+
+    Returns:
+        Formatted summary string
+
+    """
+    total = len(results)
+    successful = len([r for r in results if r["status"] == "success"])
+    failed = len([r for r in results if r["status"] == "error"])
 
     summary = f"""# Chef Environments to Ansible Inventory Conversion
 
 ## Processing Summary:
-- Total environments processed: {len(results)}
-- Successfully converted: {len([r for r in results if r["status"] == "success"])}
-- Failed conversions: {len([r for r in results if r["status"] == "error"])}
+- Total environments processed: {total}
+- Successfully converted: {successful}
+- Failed conversions: {failed}
 
 ## Environment Details:
 """
@@ -1223,35 +1447,71 @@ def _generate_complete_inventory_from_environments(
         else:
             summary += f"❌ {result['environment']}: {result['error']}\n"
 
-    if output_format in ["yaml", "both"]:
-        summary += "\n## YAML Inventory Structure:\n\n```yaml\n"
+    return summary
 
-        # Generate YAML inventory
-        inventory: dict[str, Any] = {"all": {"children": {}}}
 
-        for env_name, env_data in environments.items():
-            inventory["all"]["children"][env_name] = {
-                "hosts": {},  # Hosts to be added manually
-                "vars": _flatten_environment_vars(env_data),
-            }
+def _generate_yaml_inventory(environments: dict) -> str:
+    """
+    Generate YAML format inventory from environments.
 
-        summary += yaml.dump(inventory, default_flow_style=False, indent=2)
-        summary += "```\n"
+    Args:
+        environments: Dict of environment name to data
 
-    if output_format in ["ini", "both"]:
-        summary += "\n## INI Inventory Structure:\n\n```ini\n"
-        summary += "[all:children]\n"
-        for env_name in environments:
-            summary += f"{env_name}\n"
+    Returns:
+        YAML inventory string
+
+    """
+    import yaml
 
-        summary += "\n"
-        for env_name in environments:
-            summary += f"[{env_name}]\n"
-            summary += "# Add your hosts here\n\n"
+    inventory: dict[str, Any] = {"all": {"children": {}}}
 
-        summary += "```\n"
+    for env_name, env_data in environments.items():
+        inventory["all"]["children"][env_name] = {
+            "hosts": {},  # Hosts to be added manually
+            "vars": _flatten_environment_vars(env_data),
+        }
+
+    yaml_output = yaml.dump(inventory, default_flow_style=False, indent=2)
+    return f"\n## YAML Inventory Structure:\n\n```yaml\n{yaml_output}```\n"
+
+
+def _generate_ini_inventory(environments: dict) -> str:
+    """
+    Generate INI format inventory from environments.
+
+    Args:
+        environments: Dict of environment name to data
+
+    Returns:
+        INI inventory string
+
+    """
+    output = "\n## INI Inventory Structure:\n\n```ini\n"
+    output += "[all:children]\n"
+    for env_name in environments:
+        output += f"{env_name}\n"
+
+    output += "\n"
+    for env_name in environments:
+        output += f"[{env_name}]\n"
+        output += "# Add your hosts here\n\n"
+
+    output += "```\n"
+    return output
+
+
+def _generate_next_steps_guide(environments: dict) -> str:
+    """
+    Generate next steps and file structure guide.
+
+    Args:
+        environments: Dict of environment name to data
 
-    summary += """
+    Returns:
+        Guide string
+
+    """
+    guide = """
 ## Next Steps:
 1. Create group_vars directory structure
 2. Add environment-specific variable files
@@ -1262,7 +1522,40 @@ def _generate_complete_inventory_from_environments(
 ## File Structure to Create:
 """
     for env_name in environments:
-        summary += f"- inventory/group_vars/{env_name}.yml\n"
+        guide += f"- inventory/group_vars/{env_name}.yml\n"
+
+    return guide
+
+
+def _generate_complete_inventory_from_environments(
+    environments: dict, results: list, output_format: str
+) -> str:
+    """
+    Generate complete Ansible inventory from multiple Chef environments.
+
+    Orchestrates summary, YAML/INI generation, and guidance.
+
+    Args:
+        environments: Dict of environment name to data
+        results: List of conversion results
+        output_format: Output format ("yaml", "ini", or "both")
+
+    Returns:
+        Complete formatted inventory with summary and guidance
+
+    """
+    # Build conversion summary
+    summary = _build_conversion_summary(results)
+
+    # Generate requested inventory formats
+    if output_format in ["yaml", "both"]:
+        summary += _generate_yaml_inventory(environments)
+
+    if output_format in ["ini", "both"]:
+        summary += _generate_ini_inventory(environments)
+
+    # Add next steps guide
+    summary += _generate_next_steps_guide(environments)
 
     return summary
 
@@ -1323,7 +1616,7 @@ def _find_environment_patterns_in_content(content: str, file_path: str) -> list:
     # Common Chef environment patterns
     environment_patterns = [
         (r"node\.chef_environment", "node.chef_environment"),
-        (r"node\[['\"]\environment['\"]\]", 'node["environment"]'),
+        (r"node\[['\"]environment['\"]\]", 'node["environment"]'),
         (r"environment\s+['\"]([^'\"\n]{0,100})['\"]", "environment declaration"),
         (
             r"if\s+node\.chef_environment\s*==\s*['\"]([^'\"\n]{0,100})['\"]",
@@ -1592,43 +1885,118 @@ def _detect_encrypted_databag(content: str) -> bool:
         return False
 
 
-def _generate_databag_conversion_summary(results: list, output_dir: str) -> str:
-    """Generate summary of data bag conversion results."""
-    total_bags = len(results)
-    successful = len([r for r in results if "error" not in r])
-    encrypted = len([r for r in results if r.get("encrypted", False)])
+def _calculate_conversion_statistics(results: list) -> dict[str, int]:
+    """
+    Calculate statistics from conversion results.
 
-    summary = f"""# Data Bag Conversion Summary
+    Args:
+        results: List of conversion result dictionaries.
 
-## Statistics:
-- Total data bags processed: {total_bags}
-- Successfully converted: {successful}
-- Failed conversions: {total_bags - successful}
-- Encrypted data bags: {encrypted}
+    Returns:
+        Dictionary with 'total', 'successful', and 'encrypted' counts.
+
+    """
+    return {
+        "total": len(results),
+        "successful": len([r for r in results if "error" not in r]),
+        "encrypted": len([r for r in results if r.get("encrypted", False)]),
+    }
+
+
+def _build_statistics_section(stats: dict[str, int]) -> str:
+    """
+    Build the statistics section of the summary.
+
+    Args:
+        stats: Dictionary with conversion statistics.
+
+    Returns:
+        Formatted statistics section as markdown.
+
+    """
+    return f"""# Data Bag Conversion Summary
 
-## Generated Files:
+## Statistics:
+- Total data bags processed: {stats["total"]}
+- Successfully converted: {stats["successful"]}
+- Failed conversions: {stats["total"] - stats["successful"]}
+- Encrypted data bags: {stats["encrypted"]}
 """
+
+
+def _extract_generated_files(results: list) -> list[str]:
+    """
+    Extract unique generated file paths from results.
+
+    Args:
+        results: List of conversion result dictionaries.
+
+    Returns:
+        Sorted list of unique file paths.
+
+    """
     files_created = set()
     for result in results:
         if "error" not in result:
             target_file = result["target_file"]
             files_created.add(target_file)
+    return sorted(files_created)
 
-    for file in sorted(files_created):
-        summary += f"- {file}\n"
 
-    summary += "\n## Conversion Details:\n"
+def _build_files_section(files: list[str]) -> str:
+    """
+    Build the generated files section.
+
+    Args:
+        files: List of generated file paths.
+
+    Returns:
+        Formatted files section as markdown.
+
+    """
+    section = "\n## Generated Files:\n"
+    for file in files:
+        section += f"- {file}\n"
+    return section
+
+
+def _build_conversion_details_section(results: list) -> str:
+    """
+    Build the conversion details section.
+
+    Args:
+        results: List of conversion result dictionaries.
+
+    Returns:
+        Formatted conversion details section as markdown.
+
+    """
+    section = "\n## Conversion Details:\n"
 
     for result in results:
         if "error" in result:
-            summary += f"❌ {result['databag']}/{result['item']}: {result['error']}\n"
+            section += f"❌ {result['databag']}/{result['item']}: {result['error']}\n"
         else:
-            status = "🔒 Encrypted" if result["encrypted"] else "📄 Plain"
+            status = "🔒 Encrypted" if result.get("encrypted", False) else "📄 Plain"
             databag_item = f"{result['databag']}/{result['item']}"
             target = result["target_file"]
-            summary += f"✅ {databag_item} → {target} ({status})\n"
+            section += f"✅ {databag_item} → {target} ({status})\n"
 
-    summary += f"""
+    return section
+
+
+def _build_next_steps_section(output_dir: str) -> str:
+    """
+    Build the next steps section.
+
+    Args:
+        output_dir: Output directory path.
+
+    Returns:
+        Formatted next steps section as markdown.
+
+    """
+    return f"""
 ## Next Steps:
 1. Review generated variable files in {output_dir}/
 2. Encrypt vault files: `ansible-vault encrypt {output_dir}/*_vault.yml`
@@ -1636,7 +2004,29 @@ def _generate_databag_conversion_summary(results: list, output_dir: str) -> str:
 4. Test variable access in playbooks
 5. Remove original Chef data bags after validation
 """
-    return summary
+
+
+def _generate_databag_conversion_summary(results: list, output_dir: str) -> str:
+    """
+    Generate summary of data bag conversion results.
+
+    Args:
+        results: List of conversion result dictionaries.
+        output_dir: Output directory path.
+
+    Returns:
+        Complete formatted summary as markdown.
+
+    """
+    stats = _calculate_conversion_statistics(results)
+    files = _extract_generated_files(results)
+
+    return (
+        _build_statistics_section(stats)
+        + _build_files_section(files)
+        + _build_conversion_details_section(results)
+        + _build_next_steps_section(output_dir)
+    )
 
 
 def _extract_databag_usage_from_cookbook(cookbook_path) -> list:
@@ -1745,65 +2135,126 @@ def _analyze_databag_structure(databags_path) -> dict:
     return structure
 
 
-def _generate_databag_migration_recommendations(
-    usage_patterns: list, databag_structure: dict
-) -> str:
-    """Generate migration recommendations based on usage analysis."""
-    recommendations = []
+def _analyze_usage_patterns(usage_patterns: list) -> list[str]:
+    """
+    Analyze databag usage patterns and generate recommendations.
 
-    # Analyze usage patterns
-    if usage_patterns:
-        unique_databags = {
-            p.get("databag_name") for p in usage_patterns if p.get("databag_name")
-        }
+    Args:
+        usage_patterns: List of usage pattern dicts
+
+    Returns:
+        List of recommendation strings
+
+    """
+    recommendations: list[str] = []
+
+    if not usage_patterns:
+        return recommendations
+
+    unique_databags = {
+        p.get("databag_name") for p in usage_patterns if p.get("databag_name")
+    }
+    recommendations.append(
+        f"• Found {len(usage_patterns)} data bag references "
+        f"across {len(unique_databags)} different data bags"
+    )
+
+    # Check for encrypted usage
+    encrypted_usage = [p for p in usage_patterns if "encrypted" in p.get("type", "")]
+    if encrypted_usage:
         recommendations.append(
-            f"• Found {len(usage_patterns)} data bag references "
-            f"across {len(unique_databags)} different data bags"
+            f"• {len(encrypted_usage)} encrypted data bag references "
+            f"- convert to Ansible Vault"
         )
 
-        # Check for encrypted usage
-        encrypted_usage = [
-            p for p in usage_patterns if "encrypted" in p.get("type", "")
-        ]
-        if encrypted_usage:
-            recommendations.append(
-                f"• {len(encrypted_usage)} encrypted data bag references "
-                f"- convert to Ansible Vault"
-            )
+    # Check for complex patterns
+    search_patterns = [p for p in usage_patterns if "search" in p.get("type", "")]
+    if search_patterns:
+        recommendations.append(
+            f"• {len(search_patterns)} search patterns involving data bags "
+            f"- may need inventory integration"
+        )
 
-        # Check for complex patterns
-        search_patterns = [p for p in usage_patterns if "search" in p.get("type", "")]
-        if search_patterns:
-            recommendations.append(
-                f"• {len(search_patterns)} search patterns involving data bags "
-                f"- may need inventory integration"
-            )
+    return recommendations
 
-    # Analyze structure
-    if databag_structure:
-        total_bags = databag_structure.get("total_databags", 0)
-        encrypted_items = databag_structure.get("encrypted_items", 0)
 
-        if total_bags > 0:
-            recommendations.append(
-                f"• Convert {total_bags} data bags to group_vars/host_vars structure"
-            )
+def _analyze_databag_structure_recommendations(databag_structure: dict) -> list[str]:
+    """
+    Analyze databag structure and generate recommendations.
+
+    Args:
+        databag_structure: Dict with structure analysis
+
+    Returns:
+        List of recommendation strings
+
+    """
+    recommendations: list[str] = []
+
+    if not databag_structure:
+        return recommendations
+
+    total_bags = databag_structure.get("total_databags", 0)
+    encrypted_items = databag_structure.get("encrypted_items", 0)
+
+    if total_bags > 0:
+        recommendations.append(
+            f"• Convert {total_bags} data bags to group_vars/host_vars structure"
+        )
+
+    if encrypted_items > 0:
+        recommendations.append(
+            f"• {encrypted_items} encrypted items need Ansible Vault conversion"
+        )
+
+    return recommendations
 
-        if encrypted_items > 0:
-            recommendations.append(
-                f"• {encrypted_items} encrypted items need Ansible Vault conversion"
-            )
 
-    # Variable scope recommendations
+def _get_variable_scope_recommendations() -> list[str]:
+    """
+    Get standard variable scope recommendations.
+
+    Returns:
+        List of recommendation strings
+
+    """
+    return [
+        "• Use group_vars/ for environment-specific data (production, staging)",
+        "• Use host_vars/ for node-specific configurations",
+        "• Consider splitting large data bags into logical variable files",
+        "• Implement variable precedence hierarchy matching Chef environments",
+    ]
+
+
+def _generate_databag_migration_recommendations(
+    usage_patterns: list, databag_structure: dict
+) -> str:
+    """
+    Generate migration recommendations based on usage analysis.
+
+    Combines usage pattern analysis, structure analysis, and best practices.
+
+    Args:
+        usage_patterns: List of databag usage patterns
+        databag_structure: Dict with databag structure info
+
+    Returns:
+        Formatted recommendations string
+
+    """
+    recommendations = []
+
+    # Analyze usage patterns
+    recommendations.extend(_analyze_usage_patterns(usage_patterns))
+
+    # Analyze structure
     recommendations.extend(
-        [
-            "• Use group_vars/ for environment-specific data (production, staging)",
-            "• Use host_vars/ for node-specific configurations",
-            "• Consider splitting large data bags into logical variable files",
-            "• Implement variable precedence hierarchy matching Chef environments",
-        ]
+        _analyze_databag_structure_recommendations(databag_structure)
     )
 
+    # Add variable scope best practices
+    recommendations.extend(_get_variable_scope_recommendations())
+
     return "\n".join(recommendations)
 
 
@@ -2073,7 +2524,11 @@ def generate_playbook_from_recipe(recipe_path: str) -> str:
         Generated Ansible playbook content.
 
     """
-    return _generate_playbook_from_recipe(recipe_path)
+    from souschef.converters.playbook import (
+        generate_playbook_from_recipe as _generate_playbook,
+    )
+
+    return _generate_playbook(recipe_path)
 
 
 def convert_chef_search_to_inventory(search_query: str) -> str:
@@ -2118,6 +2573,244 @@ def analyze_chef_search_patterns(recipe_or_cookbook_path: str) -> str:
     return _analyze_chef_search_patterns(recipe_or_cookbook_path)
 
 
+@mcp.tool()
+def profile_cookbook_performance(cookbook_path: str) -> str:
+    """
+    Profile cookbook parsing performance and generate optimization report.
+
+    Analyzes the performance of parsing all cookbook components (recipes,
+    attributes, resources, templates) and provides recommendations for
+    optimization. Useful for large cookbooks or batch processing operations.
+
+    Args:
+        cookbook_path: Path to the Chef cookbook to profile.
+
+    Returns:
+        Formatted performance report with timing, memory usage, and recommendations.
+
+    """
+    from souschef.profiling import generate_cookbook_performance_report
+
+    try:
+        report = generate_cookbook_performance_report(cookbook_path)
+        return str(report)
+    except Exception as e:
+        return format_error_with_context(
+            e, "profiling cookbook performance", cookbook_path
+        )
+
+
+@mcp.tool()
+def profile_parsing_operation(
+    operation: str, file_path: str, detailed: bool = False
+) -> str:
+    """
+    Profile a single parsing operation with detailed performance metrics.
+
+    Measures execution time, memory usage, and optionally provides detailed
+    function call statistics for a specific parsing operation.
+
+    Args:
+        operation: Type of operation to profile ('recipe', 'attributes', 'resource', 'template').
+        file_path: Path to the file to parse.
+        detailed: If True, include detailed function call statistics.
+
+    Returns:
+        Performance metrics for the operation.
+
+    """
+    from souschef.profiling import detailed_profile_function, profile_function
+
+    operation_map = {
+        "recipe": parse_recipe,
+        "attributes": parse_attributes,
+        "resource": parse_custom_resource,
+        "template": parse_template,
+    }
+
+    if operation not in operation_map:
+        return (
+            f"Error: Invalid operation '{operation}'\n\n"
+            f"Supported operations: {', '.join(operation_map.keys())}"
+        )
+
+    func = operation_map[operation]
+
+    try:
+        if detailed:
+            _, profile_result = detailed_profile_function(func, file_path)
+            result = str(profile_result)
+            if profile_result.function_stats.get("top_functions"):
+                result += "\n\nDetailed Function Statistics:\n"
+                result += profile_result.function_stats["top_functions"]
+            return result
+        else:
+            _, profile_result = profile_function(func, file_path)
+            return str(profile_result)
+    except Exception as e:
+        return format_error_with_context(e, f"profiling {operation} parsing", file_path)
+
+
+# CI/CD Pipeline Generation Tools
+
+
+@mcp.tool()
+def generate_jenkinsfile_from_chef(
+    cookbook_path: str,
+    pipeline_name: str = "chef-to-ansible-pipeline",
+    pipeline_type: str = "declarative",
+    enable_parallel: str = "yes",
+) -> str:
+    """
+    Generate Jenkins pipeline from Chef cookbook CI/CD patterns.
+
+    Analyzes Chef testing tools (Test Kitchen, ChefSpec, InSpec, Foodcritic)
+    and generates equivalent Jenkins pipeline stages (Declarative or Scripted).
+
+    Args:
+        cookbook_path: Path to Chef cookbook directory.
+        pipeline_name: Name for the Jenkins pipeline.
+        pipeline_type: Pipeline type - 'declarative' (recommended) or 'scripted'.
+        enable_parallel: Enable parallel test execution - 'yes' or 'no'.
+
+    Returns:
+        Jenkinsfile content (Groovy DSL) for Jenkins pipeline.
+
+    """
+    from souschef.ci.jenkins_pipeline import generate_jenkinsfile_from_chef_ci
+
+    try:
+        # Convert string to boolean
+        enable_parallel_bool = enable_parallel.lower() in ("yes", "true", "1")
+
+        result = generate_jenkinsfile_from_chef_ci(
+            cookbook_path=cookbook_path,
+            pipeline_name=pipeline_name,
+            pipeline_type=pipeline_type,
+            enable_parallel=enable_parallel_bool,
+        )
+        return result
+    except FileNotFoundError as e:
+        return format_error_with_context(e, "generating Jenkinsfile", cookbook_path)
+    except Exception as e:
+        return format_error_with_context(e, "generating Jenkinsfile", cookbook_path)
+
+
+@mcp.tool()
+def generate_gitlab_ci_from_chef(
+    cookbook_path: str,
+    project_name: str = "chef-to-ansible",
+    enable_cache: str = "yes",
+    enable_artifacts: str = "yes",
+) -> str:
+    """
+    Generate GitLab CI configuration from Chef cookbook CI/CD patterns.
+
+    Analyzes Chef testing tools and generates equivalent GitLab CI stages
+    with caching, artifacts, and parallel execution support.
+
+    Args:
+        cookbook_path: Path to Chef cookbook directory.
+        project_name: GitLab project name.
+        enable_cache: Enable caching for dependencies - 'yes' or 'no'.
+        enable_artifacts: Enable artifacts for test results - 'yes' or 'no'.
+
+    Returns:
+        .gitlab-ci.yml content (YAML) for GitLab CI/CD.
+
+    """
+    from souschef.ci.gitlab_ci import generate_gitlab_ci_from_chef_ci
+
+    try:
+        enable_cache_bool = enable_cache.lower() in ("yes", "true", "1")
+        enable_artifacts_bool = enable_artifacts.lower() in ("yes", "true", "1")
+        result = generate_gitlab_ci_from_chef_ci(
+            cookbook_path=cookbook_path,
+            project_name=project_name,
+            enable_cache=enable_cache_bool,
+            enable_artifacts=enable_artifacts_bool,
+        )
+        return result
+    except FileNotFoundError as e:
+        return format_error_with_context(
+            e,
+            "generating .gitlab-ci.yml",
+            cookbook_path,
+        )
+    except Exception as e:
+        return format_error_with_context(e, "generating .gitlab-ci.yml", cookbook_path)
+
+
+@mcp.tool()
+def generate_github_workflow_from_chef(
+    cookbook_path: str,
+    workflow_name: str = "Chef Cookbook CI",
+    enable_cache: str = "yes",
+    enable_artifacts: str = "yes",
+) -> str:
+    """
+    Generate GitHub Actions workflow from Chef cookbook CI/CD patterns.
+
+    Analyzes Chef testing tools and generates equivalent GitHub Actions workflow
+    with caching, artifacts, and matrix strategy support.
+
+    Args:
+        cookbook_path: Path to Chef cookbook directory.
+        workflow_name: GitHub Actions workflow name.
+        enable_cache: Enable caching for dependencies - 'yes' or 'no'.
+        enable_artifacts: Enable artifacts for test results - 'yes' or 'no'.
+
+    Returns:
+        GitHub Actions workflow YAML content (.github/workflows/*.yml).
+
+    """
+    from souschef.ci.github_actions import generate_github_workflow_from_chef_ci
+
+    try:
+        enable_cache_bool = enable_cache.lower() in ("yes", "true", "1")
+        enable_artifacts_bool = enable_artifacts.lower() in ("yes", "true", "1")
+        result = generate_github_workflow_from_chef_ci(
+            cookbook_path=cookbook_path,
+            workflow_name=workflow_name,
+            enable_cache=enable_cache_bool,
+            enable_artifacts=enable_artifacts_bool,
+        )
+        return result
+    except FileNotFoundError as e:
+        return format_error_with_context(
+            e,
+            "generating GitHub Actions workflow",
+            cookbook_path,
+        )
+    except Exception as e:
+        return format_error_with_context(
+            e, "generating GitHub Actions workflow", cookbook_path
+        )
+
+
+@mcp.tool()
+def parse_chef_migration_assessment(
+    cookbook_paths: str,
+    migration_scope: str = "full",
+    target_platform: str = "ansible_awx",
+) -> dict[str, Any]:
+    """
+    Parse Chef cookbook migration assessment and return as dictionary.
+
+    Args:
+        cookbook_paths: Comma-separated paths to Chef cookbooks or cookbook directory
+        migration_scope: Scope of migration (full, recipes_only, infrastructure_only)
+        target_platform: Target platform (ansible_awx, ansible_core, ansible_tower)
+
+    Returns:
+        Dictionary containing assessment data with complexity, recommendations, etc.
+
+    """
+    return _parse_chef_migration_assessment(
+        cookbook_paths, migration_scope, target_platform
+    )
+
+
 # AWX/AAP deployment wrappers for backward compatibility
 def main() -> None:
     """