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

souschef/server.py

@@ -10,7 +10,7 @@ from mcp.server.fastmcp import FastMCP
 
 # Import assessment functions with aliases to avoid name conflicts
 from souschef.assessment import (
-    analyze_cookbook_dependencies as _analyze_cookbook_dependencies,
+    analyse_cookbook_dependencies as _analyse_cookbook_dependencies,
 )
 from souschef.assessment import (
     assess_chef_migration_complexity as _assess_chef_migration_complexity,
@@ -21,13 +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
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.converters.habitat import (  # noqa: F401
     _add_service_build,
     _add_service_dependencies,
@@ -49,7 +52,7 @@ from souschef.converters.habitat import (
 )
 
 # Re-exports of playbook internal functions for backward compatibility (tests)
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# 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,
@@ -76,7 +79,7 @@ from souschef.converters.playbook import (  # noqa: F401
 
 # Import playbook converter functions
 from souschef.converters.playbook import (
-    analyze_chef_search_patterns as _analyze_chef_search_patterns,
+    analyse_chef_search_patterns as _analyse_chef_search_patterns,
 )
 from souschef.converters.playbook import (
     convert_chef_search_to_inventory as _convert_chef_search_to_inventory,
@@ -84,11 +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,
-)
 
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# 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,
@@ -101,7 +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
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.core.constants import (  # noqa: F401
     ACTION_TO_STATE,
     ANSIBLE_SERVICE_MODULE,
@@ -113,19 +113,19 @@ from souschef.core.constants import (  # noqa: F401
 # Import core utilities
 from souschef.core.errors import format_error_with_context
 
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# 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
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# 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
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.core.validation import (  # noqa: F401
     ValidationCategory,
     ValidationEngine,
@@ -137,10 +137,10 @@ 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
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.deployment import (  # noqa: F401
-    _analyze_cookbook_for_awx,
-    _analyze_cookbooks_directory,
+    _analyse_cookbook_for_awx,
+    _analyse_cookbooks_directory,
     _detect_deployment_patterns_in_recipe,
     _extract_cookbook_attributes,
     _extract_cookbook_dependencies,
@@ -151,7 +151,7 @@ from souschef.deployment import (  # noqa: F401
     _generate_survey_fields_from_attributes,
     _parse_chef_runlist,
     _recommend_ansible_strategies,
-    analyze_chef_application_patterns,
+    analyse_chef_application_patterns,
     convert_chef_deployment_to_ansible_strategy,
     generate_awx_inventory_source_from_chef,
     generate_awx_job_template_from_cookbook,
@@ -163,9 +163,6 @@ from souschef.deployment import (  # noqa: F401
 
 # Re-exports for backward compatibility (used by tests)
 # These are imported and re-exported intentionally
-from souschef.deployment import (
-    analyze_chef_application_patterns as _analyze_chef_application_patterns,
-)
 from souschef.deployment import (
     convert_chef_deployment_to_ansible_strategy as _convert_chef_deployment_to_ansible_strategy,
 )
@@ -192,7 +189,7 @@ from souschef.deployment import (
 from souschef.filesystem import list_directory as _list_directory
 from souschef.filesystem import read_file as _read_file
 
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.attributes import (  # noqa: F401
     _extract_attributes,
     _format_attributes,
@@ -204,7 +201,7 @@ from souschef.parsers.attributes import (  # noqa: F401
 # Import parser functions
 from souschef.parsers.attributes import parse_attributes as _parse_attributes
 
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.habitat import (  # noqa: F401
     _extract_plan_array,
     _extract_plan_exports,
@@ -217,16 +214,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)
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# 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,
+)
 
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.metadata import (  # noqa: F401
     _extract_metadata,
     _format_cookbook_structure,
@@ -235,9 +240,12 @@ 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
 
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# codeql[py/unused-import]: Backward compatibility exports for test suite
 from souschef.parsers.recipe import (  # noqa: F401
     _extract_conditionals,
     _extract_resources,
@@ -245,14 +253,14 @@ from souschef.parsers.recipe import (  # noqa: F401
 )
 from souschef.parsers.recipe import parse_recipe as _parse_recipe
 
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# 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
 
-# lgtm[py/unused-import]: Backward compatibility exports for test suite
+# 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,
@@ -354,6 +362,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:
     """
@@ -537,6 +560,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.
@@ -548,108 +572,23 @@ def parse_inspec_profile(path: str) -> str:
         JSON string with parsed controls, or error message.
 
     """
-    try:
-        # Validate input
-        if not path or not path.strip():
-            return (
-                "Error: Path cannot be empty\n\n"
-                "Suggestion: Provide a path to an InSpec profile directory or control file"
-            )
-
-        profile_path = _normalize_path(path)
-
-        if not profile_path.exists():
-            return (
-                f"Error: Path does not exist: {path}\n\n"
-                "Suggestion: Check that the path is correct and the InSpec profile exists"
-            )
-
-        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}\n\n"
-                "Suggestion: Provide a directory or file path, not a special file type"
-            )
-
-        return json.dumps(
-            {
-                "profile_path": str(profile_path),
-                "controls_count": len(controls),
-                "controls": controls,
-            },
-            indent=2,
-        )
-
-    except (FileNotFoundError, RuntimeError) as e:
-        return format_error_with_context(e, "parsing InSpec profile", path)
-    except Exception as e:
-        return format_error_with_context(e, "parsing InSpec profile", path)
+    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 format_error_with_context(
-            e, f"converting InSpec to {output_format}", inspec_path
-        )
+    return _convert_inspec_test(inspec_path, output_format)
 
 
 def _extract_resources_from_parse_result(parse_result: str) -> list[dict[str, Any]]:
@@ -961,9 +900,9 @@ def generate_ansible_vault_from_databags(
 
 
 @mcp.tool()
-def analyze_chef_databag_usage(cookbook_path: str, databags_path: str = "") -> str:
+def analyse_chef_databag_usage(cookbook_path: str, databags_path: str = "") -> str:
     """
-    Analyze Chef cookbook for data bag usage and provide migration recommendations.
+    Analyse Chef cookbook for data bag usage and provide migration recommendations.
 
     Args:
         cookbook_path: Path to Chef cookbook
@@ -986,7 +925,7 @@ def analyze_chef_databag_usage(cookbook_path: str, databags_path: str = "") -> s
         if databags_path:
             databags = _normalize_path(databags_path)
             if databags.exists():
-                databag_structure = _analyze_databag_structure(databags)
+                databag_structure = _analyse_databag_structure(databags)
 
         # Generate recommendations
         recommendations = _generate_databag_migration_recommendations(
@@ -1122,11 +1061,11 @@ def generate_inventory_from_chef_environments(
 
 
 @mcp.tool()
-def analyze_chef_environment_usage(
+def analyse_chef_environment_usage(
     cookbook_path: str, environments_path: str = ""
 ) -> str:
     """
-    Analyze Chef cookbook for environment usage.
+    Analyse Chef cookbook for environment usage.
 
     Provides migration recommendations.
 
@@ -1151,7 +1090,7 @@ def analyze_chef_environment_usage(
         if environments_path:
             environments = _normalize_path(environments_path)
             if environments.exists():
-                environment_structure = _analyze_environments_structure(environments)
+                environment_structure = _analyse_environments_structure(environments)
 
         # Generate recommendations
         recommendations = _generate_environment_migration_recommendations(
@@ -1220,6 +1159,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
@@ -1231,37 +1347,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
 
 
@@ -1527,7 +1613,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})['\"]",
@@ -1557,8 +1643,8 @@ def _find_environment_patterns_in_content(content: str, file_path: str) -> list:
     return patterns
 
 
-def _analyze_environments_structure(environments_path) -> dict:
-    """Analyze the structure of Chef environments directory."""
+def _analyse_environments_structure(environments_path) -> dict:
+    """Analyse the structure of Chef environments directory."""
     structure: dict[str, Any] = {"total_environments": 0, "environments": {}}
 
     for env_file in environments_path.glob("*.rb"):
@@ -1590,8 +1676,8 @@ def _analyze_environments_structure(environments_path) -> dict:
     return structure
 
 
-def _analyze_usage_pattern_recommendations(usage_patterns: list) -> list[str]:
-    """Analyze usage patterns and generate recommendations."""
+def _analyse_usage_pattern_recommendations(usage_patterns: list) -> list[str]:
+    """Analyse usage patterns and generate recommendations."""
     if not usage_patterns:
         return []
 
@@ -1622,8 +1708,8 @@ def _analyze_usage_pattern_recommendations(usage_patterns: list) -> list[str]:
     return recommendations
 
 
-def _analyze_structure_recommendations(env_structure: dict) -> list[str]:
-    """Analyze environment structure and generate recommendations."""
+def _analyse_structure_recommendations(env_structure: dict) -> list[str]:
+    """Analyse environment structure and generate recommendations."""
     if not env_structure:
         return []
 
@@ -1671,8 +1757,8 @@ def _generate_environment_migration_recommendations(
 ) -> str:
     """Generate migration recommendations based on environment usage analysis."""
     recommendations = []
-    recommendations.extend(_analyze_usage_pattern_recommendations(usage_patterns))
-    recommendations.extend(_analyze_structure_recommendations(env_structure))
+    recommendations.extend(_analyse_usage_pattern_recommendations(usage_patterns))
+    recommendations.extend(_analyse_structure_recommendations(env_structure))
     recommendations.extend(_get_general_migration_recommendations())
 
     return "\n".join(recommendations)
@@ -1888,7 +1974,7 @@ def _build_conversion_details_section(results: list) -> str:
         if "error" in result:
             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"]
             section += f"✅ {databag_item} → {target} ({status})\n"
@@ -2001,8 +2087,8 @@ def _find_databag_patterns_in_content(content: str, file_path: str) -> list:
     return patterns
 
 
-def _analyze_databag_structure(databags_path) -> dict:
-    """Analyze the structure of Chef data bags directory."""
+def _analyse_databag_structure(databags_path) -> dict:
+    """Analyse the structure of Chef data bags directory."""
     structure: dict[str, Any] = {
         "total_databags": 0,
         "total_items": 0,
@@ -2046,9 +2132,9 @@ def _analyze_databag_structure(databags_path) -> dict:
     return structure
 
 
-def _analyze_usage_patterns(usage_patterns: list) -> list[str]:
+def _analyse_usage_patterns(usage_patterns: list) -> list[str]:
     """
-    Analyze databag usage patterns and generate recommendations.
+    Analyse databag usage patterns and generate recommendations.
 
     Args:
         usage_patterns: List of usage pattern dicts
@@ -2089,9 +2175,9 @@ def _analyze_usage_patterns(usage_patterns: list) -> list[str]:
     return recommendations
 
 
-def _analyze_databag_structure_recommendations(databag_structure: dict) -> list[str]:
+def _analyse_databag_structure_recommendations(databag_structure: dict) -> list[str]:
     """
-    Analyze databag structure and generate recommendations.
+    Analyse databag structure and generate recommendations.
 
     Args:
         databag_structure: Dict with structure analysis
@@ -2156,11 +2242,11 @@ def _generate_databag_migration_recommendations(
     recommendations = []
 
     # Analyze usage patterns
-    recommendations.extend(_analyze_usage_patterns(usage_patterns))
+    recommendations.extend(_analyse_usage_patterns(usage_patterns))
 
     # Analyze structure
     recommendations.extend(
-        _analyze_databag_structure_recommendations(databag_structure)
+        _analyse_databag_structure_recommendations(databag_structure)
     )
 
     # Add variable scope best practices
@@ -2240,7 +2326,7 @@ mcp.tool()(_generate_awx_inventory_source_from_chef)
 mcp.tool()(_convert_chef_deployment_to_ansible_strategy)
 mcp.tool()(_generate_blue_green_deployment_playbook)
 mcp.tool()(_generate_canary_deployment_strategy)
-mcp.tool()(_analyze_chef_application_patterns)
+mcp.tool()(analyse_chef_application_patterns)
 
 
 # ============================================================================
@@ -2300,9 +2386,9 @@ def generate_migration_plan(
 
 
 @mcp.tool()
-def analyze_cookbook_dependencies(cookbook_paths: str) -> str:
+def analyse_cookbook_dependencies(cookbook_paths: str) -> str:
     """
-    Analyze dependencies between Chef cookbooks.
+    Analyse dependencies between Chef cookbooks.
 
     Maps cookbook dependencies, identifies circular dependencies, and
     recommends migration order.
@@ -2314,7 +2400,7 @@ def analyze_cookbook_dependencies(cookbook_paths: str) -> str:
         Dependency analysis report in markdown format.
 
     """
-    return _analyze_cookbook_dependencies(cookbook_paths)
+    return _analyse_cookbook_dependencies(cookbook_paths)
 
 
 @mcp.tool()
@@ -2435,7 +2521,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:
@@ -2466,9 +2556,10 @@ def generate_dynamic_inventory_script(search_queries: str) -> str:
     return _generate_dynamic_inventory_script(search_queries)
 
 
-def analyze_chef_search_patterns(recipe_or_cookbook_path: str) -> str:
+@mcp.tool()
+def analyse_chef_search_patterns(recipe_or_cookbook_path: str) -> str:
     """
-    Analyze Chef search patterns in recipe or cookbook.
+    Analyse Chef search patterns in recipe or cookbook.
 
     Args:
         recipe_or_cookbook_path: Path to recipe or cookbook.
@@ -2477,7 +2568,7 @@ def analyze_chef_search_patterns(recipe_or_cookbook_path: str) -> str:
         Analysis of search patterns found.
 
     """
-    return _analyze_chef_search_patterns(recipe_or_cookbook_path)
+    return _analyse_chef_search_patterns(recipe_or_cookbook_path)
 
 
 @mcp.tool()
@@ -2558,6 +2649,166 @@ def profile_parsing_operation(
         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:
     """