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

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",

souschef/parsers/inspec.py

@@ -8,6 +8,14 @@ from typing import Any
 from souschef.core.constants import ERROR_PREFIX, INSPEC_END_INDENT, INSPEC_SHOULD_EXIST
 from souschef.core.path_utils import _normalize_path, _safe_join
 
+# Regex patterns used across converters
+_VERSION_PATTERN = r"match\s+/([^/]+)/"
+_MODE_PATTERN = r"cmp\s+'([^']+)'"
+_OWNER_PATTERN = r"eq\s+['\"]([^'\"]+)['\"]"
+
+# ServerSpec formatting constants
+_SERVERSPEC_END = "  end"
+
 
 def parse_inspec_profile(path: str) -> str:
     """
@@ -21,17 +29,32 @@ def parse_inspec_profile(path: str) -> str:
 
     """
     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}"
+            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}"
+            return (
+                f"Error: Invalid path type: {path}\n\n"
+                "Suggestion: Provide a directory or file path, not a special file type"
+            )
 
         return json.dumps(
             {
@@ -43,18 +66,19 @@ def parse_inspec_profile(path: str) -> str:
         )
 
     except (FileNotFoundError, RuntimeError) as e:
-        return f"Error: {e}"
+        return f"Error: {e}\n\nSuggestion: Verify the path exists and is accessible"
     except Exception as e:
         return f"An error occurred while parsing InSpec profile: {e}"
 
 
-def convert_inspec_to_test(inspec_path: str, output_format: str = "testinfra") -> str:
+def convert_inspec_to_test(inspec_path: str, output_format: str = "testinfra") -> str:  # noqa: C901
     """
-    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.
@@ -73,19 +97,51 @@ def convert_inspec_to_test(inspec_path: str, output_format: str = "testinfra") -
         controls = profile_data["controls"]
 
         if not controls:
-            return "Warning: No controls found to convert"
+            return "Error: No controls found in InSpec profile"
 
         # Convert each control
-        converted = []
-        for control in controls:
-            if output_format == "testinfra":
-                converted.append(_convert_inspec_to_testinfra(control))
-            elif output_format == "ansible_assert":
-                converted.append(_convert_inspec_to_ansible_assert(control))
-            else:
-                return f"Error: Unsupported output format: {output_format}"
+        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("")
+
+        elif output_format == "serverspec":
+            converted_tests.append("# frozen_string_literal: true")
+            converted_tests.append("")
+            converted_tests.append("require 'serverspec'")
+            converted_tests.append("")
+            converted_tests.append("set :backend, :exec")
+            converted_tests.append("")
+            for control in controls:
+                serverspec_code = _convert_inspec_to_serverspec(control)
+                converted_tests.append(serverspec_code)
+
+        elif output_format == "goss":
+            # Goss uses a single YAML spec for all tests
+            return _convert_inspec_to_goss(controls)
 
-        return "\n".join(converted)
+        else:
+            error_msg = (
+                f"Error: Unsupported format '{output_format}'. "
+                "Use 'testinfra', 'ansible_assert', 'serverspec', or 'goss'"
+            )
+            return error_msg
+
+        return "\n".join(converted_tests)
 
     except json.JSONDecodeError as e:
         return f"Error parsing InSpec result: {e}"
@@ -388,7 +444,7 @@ def _convert_package_to_testinfra(
         if "be_installed" in exp["matcher"]:
             lines.append("    assert pkg.is_installed")
         elif exp["type"] == "its" and exp["property"] == "version":
-            version_match = re.search(r"match\s+/([^/]+)/", exp["matcher"])
+            version_match = re.search(_VERSION_PATTERN, exp["matcher"])
             if version_match:
                 version = version_match.group(1)
                 lines.append(f'    assert pkg.version.startswith("{version}")')
@@ -500,6 +556,275 @@ def _convert_inspec_to_testinfra(control: dict[str, Any]) -> str:
     return "\n".join(lines)
 
 
+def _convert_package_to_serverspec(
+    lines: list[str], resource_name: str, expectations: list[dict[str, Any]]
+) -> None:
+    """
+    Convert package resource to ServerSpec expectations.
+
+    Args:
+        lines: List to append test lines to.
+        resource_name: Name of the package.
+        expectations: List of InSpec expectations.
+
+    """
+    lines.append(f"  describe package('{resource_name}') do")
+    for exp in expectations:
+        if "be_installed" in exp["matcher"]:
+            lines.append("    it { should be_installed }")
+        elif exp["type"] == "its" and exp["property"] == "version":
+            version_match = re.search(_VERSION_PATTERN, exp["matcher"])
+            if version_match:
+                version = version_match.group(1)
+                lines.append(f"    its('version') {{ should match /{version}/ }}")
+    lines.append(_SERVERSPEC_END)
+
+
+def _convert_service_to_serverspec(
+    lines: list[str], resource_name: str, expectations: list[dict[str, Any]]
+) -> None:
+    """
+    Convert service resource to ServerSpec expectations.
+
+    Args:
+        lines: List to append test lines to.
+        resource_name: Name of the service.
+        expectations: List of InSpec expectations.
+
+    """
+    lines.append(f"  describe service('{resource_name}') do")
+    for exp in expectations:
+        if "be_running" in exp["matcher"]:
+            lines.append("    it { should be_running }")
+        elif "be_enabled" in exp["matcher"]:
+            lines.append("    it { should be_enabled }")
+    lines.append(_SERVERSPEC_END)
+
+
+def _convert_file_to_serverspec(
+    lines: list[str], resource_name: str, expectations: list[dict[str, Any]]
+) -> None:
+    """
+    Convert file resource to ServerSpec expectations.
+
+    Args:
+        lines: List to append test lines to.
+        resource_name: Path to the file.
+        expectations: List of InSpec expectations.
+
+    """
+    lines.append(f"  describe file('{resource_name}') do")
+    for exp in expectations:
+        if "exist" in exp["matcher"]:
+            lines.append("    it { should exist }")
+        elif exp["type"] == "its" and exp["property"] == "mode":
+            mode_match = re.search(_MODE_PATTERN, exp["matcher"])
+            if mode_match:
+                mode = mode_match.group(1)
+                lines.append(f"    its('mode') {{ should cmp '{mode}' }}")
+        elif exp["type"] == "its" and exp["property"] == "owner":
+            owner_match = re.search(_OWNER_PATTERN, exp["matcher"])
+            if owner_match:
+                owner = owner_match.group(1)
+                lines.append(f"    its('owner') {{ should eq '{owner}' }}")
+    lines.append(_SERVERSPEC_END)
+
+
+def _convert_port_to_serverspec(
+    lines: list[str], resource_name: str, expectations: list[dict[str, Any]]
+) -> None:
+    """
+    Convert port resource to ServerSpec expectations.
+
+    Args:
+        lines: List to append test lines to.
+        resource_name: Port number or address.
+        expectations: List of InSpec expectations.
+
+    """
+    lines.append(f"  describe port({resource_name}) do")
+    for exp in expectations:
+        if "be_listening" in exp["matcher"]:
+            lines.append("    it { should be_listening }")
+    lines.append(_SERVERSPEC_END)
+
+
+def _convert_inspec_to_serverspec(control: dict[str, Any]) -> str:
+    """
+    Convert InSpec control to ServerSpec test.
+
+    Args:
+        control: Parsed InSpec control dictionary.
+
+    Returns:
+        ServerSpec test code as string.
+
+    """
+    lines = []
+
+    # Add describe block for the control
+    lines.append(f"describe '{control.get('title') or control['id']}' do")
+
+    # Convert each test within the control
+    for test in control["tests"]:
+        resource_type = test["resource_type"]
+        resource_name = test["resource_name"]
+        expectations = test["expectations"]
+
+        # Map InSpec resources to ServerSpec using dedicated converters
+        if resource_type == "package":
+            _convert_package_to_serverspec(lines, resource_name, expectations)
+        elif resource_type == "service":
+            _convert_service_to_serverspec(lines, resource_name, expectations)
+        elif resource_type == "file":
+            _convert_file_to_serverspec(lines, resource_name, expectations)
+        elif resource_type == "port":
+            _convert_port_to_serverspec(lines, resource_name, expectations)
+
+    lines.append("end")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _convert_package_to_goss(expectations: list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    Convert package resource to Goss specification.
+
+    Args:
+        expectations: List of InSpec expectations.
+
+    Returns:
+        Goss package specification dictionary.
+
+    """
+    spec: dict[str, Any] = {}
+    for exp in expectations:
+        if "be_installed" in exp["matcher"]:
+            spec["installed"] = True
+        elif exp["type"] == "its" and exp["property"] == "version":
+            version_match = re.search(_VERSION_PATTERN, exp["matcher"])
+            if version_match:
+                spec["versions"] = [version_match.group(1)]
+    return spec
+
+
+def _convert_service_to_goss(expectations: list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    Convert service resource to Goss specification.
+
+    Args:
+        expectations: List of InSpec expectations.
+
+    Returns:
+        Goss service specification dictionary.
+
+    """
+    spec: dict[str, Any] = {}
+    for exp in expectations:
+        if "be_running" in exp["matcher"]:
+            spec["running"] = True
+        elif "be_enabled" in exp["matcher"]:
+            spec["enabled"] = True
+    return spec
+
+
+def _convert_file_to_goss(expectations: list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    Convert file resource to Goss specification.
+
+    Args:
+        expectations: List of InSpec expectations.
+
+    Returns:
+        Goss file specification dictionary.
+
+    """
+    spec: dict[str, Any] = {}
+    for exp in expectations:
+        if "exist" in exp["matcher"]:
+            spec["exists"] = True
+        elif exp["type"] == "its" and exp["property"] == "mode":
+            mode_match = re.search(_MODE_PATTERN, exp["matcher"])
+            if mode_match:
+                spec["mode"] = mode_match.group(1)
+        elif exp["type"] == "its" and exp["property"] == "owner":
+            owner_match = re.search(_OWNER_PATTERN, exp["matcher"])
+            if owner_match:
+                spec["owner"] = owner_match.group(1)
+    return spec
+
+
+def _convert_port_to_goss(expectations: list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    Convert port resource to Goss specification.
+
+    Args:
+        expectations: List of InSpec expectations.
+
+    Returns:
+        Goss port specification dictionary.
+
+    """
+    spec: dict[str, Any] = {}
+    for exp in expectations:
+        if "be_listening" in exp["matcher"]:
+            spec["listening"] = True
+    return spec
+
+
+def _convert_inspec_to_goss(controls: list[dict[str, Any]]) -> str:
+    """
+    Convert InSpec controls to Goss YAML specification.
+
+    Args:
+        controls: List of parsed InSpec control dictionaries.
+
+    Returns:
+        Goss specification as YAML string.
+
+    """
+    goss_spec: dict[str, dict[str, Any]] = {
+        "package": {},
+        "service": {},
+        "file": {},
+        "port": {},
+    }
+
+    # Process all controls and group by resource type
+    for control in controls:
+        for test in control["tests"]:
+            resource_type = test["resource_type"]
+            resource_name = test["resource_name"]
+            expectations = test["expectations"]
+
+            if resource_type == "package":
+                spec = _convert_package_to_goss(expectations)
+                goss_spec["package"][resource_name] = spec
+            elif resource_type == "service":
+                spec = _convert_service_to_goss(expectations)
+                goss_spec["service"][resource_name] = spec
+            elif resource_type == "file":
+                spec = _convert_file_to_goss(expectations)
+                goss_spec["file"][resource_name] = spec
+            elif resource_type == "port":
+                # Goss uses string format for ports
+                port_key = f"tcp://{resource_name}"
+                spec = _convert_port_to_goss(expectations)
+                goss_spec["port"][port_key] = spec
+
+    # Remove empty sections
+    goss_spec = {k: v for k, v in goss_spec.items() if v}
+
+    # Convert to YAML (using JSON for now, will need PyYAML for proper YAML)
+    try:
+        import yaml
+
+        return yaml.dump(goss_spec, default_flow_style=False, sort_keys=False)
+    except ImportError:
+        # Fallback to JSON if PyYAML not available
+        return json.dumps(goss_spec, indent=2)
+
+
 def _convert_package_to_ansible_assert(
     lines: list[str], resource_name: str, expectations: list[dict[str, Any]]
 ) -> None:
@@ -566,7 +891,7 @@ def _convert_inspec_to_ansible_assert(control: dict[str, Any]) -> str:
 
     """
     lines = [
-        f"- name: Verify {control['title'] or control['id']}",
+        f"- name: Verify {control.get('title') or control['id']}",
         "  ansible.builtin.assert:",
         "    that:",
     ]

souschef/parsers/metadata.py

@@ -45,6 +45,36 @@ def read_cookbook_metadata(path: str) -> str:
         return f"An error occurred: {e}"
 
 
+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.
+
+    """
+    try:
+        file_path = _normalize_path(path)
+        content = file_path.read_text(encoding="utf-8")
+
+        metadata = _extract_metadata(content)
+        return metadata
+
+    except ValueError as e:
+        return {"error": str(e)}
+    except FileNotFoundError:
+        return {"error": ERROR_FILE_NOT_FOUND.format(path=path)}
+    except IsADirectoryError:
+        return {"error": ERROR_IS_DIRECTORY.format(path=path)}
+    except PermissionError:
+        return {"error": ERROR_PERMISSION_DENIED.format(path=path)}
+    except Exception as e:
+        return {"error": f"An error occurred: {e}"}
+
+
 def _scan_cookbook_directory(
     cookbook_path, dir_name: str
 ) -> tuple[str, list[str]] | None: