mcp-souschef 2.1.2__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/habitat.py

@@ -205,6 +205,32 @@ def _extract_plan_exports(content: str, var_name: str) -> list[dict[str, str]]:
     return exports
 
 
+def _is_quote_blocked(
+    ch: str, in_single_quote: bool, in_double_quote: bool, in_backtick: bool
+) -> bool:
+    """Check if a quote character is blocked by other active quotes."""
+    if ch == "'":
+        return in_double_quote or in_backtick
+    if ch == '"':
+        return in_single_quote or in_backtick
+    if ch == "`":
+        return in_single_quote or in_double_quote
+    return False
+
+
+def _toggle_quote(
+    ch: str, in_single_quote: bool, in_double_quote: bool, in_backtick: bool
+) -> tuple[bool, bool, bool]:
+    """Toggle the appropriate quote state based on character."""
+    if ch == "'":
+        return not in_single_quote, in_double_quote, in_backtick
+    if ch == '"':
+        return in_single_quote, not in_double_quote, in_backtick
+    if ch == "`":
+        return in_single_quote, in_double_quote, not in_backtick
+    return in_single_quote, in_double_quote, in_backtick
+
+
 def _update_quote_state(
     ch: str,
     in_single_quote: bool,
@@ -213,18 +239,21 @@ def _update_quote_state(
     escape_next: bool,
 ) -> tuple[bool, bool, bool, bool]:
     """Update quote tracking state for shell script parsing."""
+    # Handle escape sequences
     if escape_next:
         return in_single_quote, in_double_quote, in_backtick, False
 
     if ch == "\\":
         return in_single_quote, in_double_quote, in_backtick, True
 
-    if ch == "'" and not in_double_quote and not in_backtick:
-        return not in_single_quote, in_double_quote, in_backtick, False
-    if ch == '"' and not in_single_quote and not in_backtick:
-        return in_single_quote, not in_double_quote, in_backtick, False
-    if ch == "`" and not in_single_quote and not in_double_quote:
-        return in_single_quote, in_double_quote, not in_backtick, False
+    # Handle quote characters
+    if ch in ("'", '"', "`") and not _is_quote_blocked(
+        ch, in_single_quote, in_double_quote, in_backtick
+    ):
+        single, double, backtick = _toggle_quote(
+            ch, in_single_quote, in_double_quote, in_backtick
+        )
+        return single, double, backtick, False
 
     return in_single_quote, in_double_quote, in_backtick, False
 

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:",
     ]
@@ -616,6 +941,50 @@ def _generate_inspec_package_checks(
     return lines
 
 
+def _generate_inspec_resource_checks(
+    resource_type: str,
+    resource_name: str,
+    properties: dict[str, Any] | None = None,
+    custom_checks: list[str] | None = None,
+) -> list[str]:
+    """
+    Generate InSpec checks for a resource using a generic pattern.
+
+    Args:
+        resource_type: InSpec resource type (e.g., 'file', 'user', 'service').
+        resource_name: Name/path of the resource.
+        properties: Optional resource properties to check.
+        custom_checks: Optional list of custom check lines.
+
+    Returns:
+        List of InSpec check lines.
+
+    """
+    lines = [f"  describe {resource_type}('{resource_name}') do"]
+
+    # Add custom checks if provided
+    if custom_checks:
+        lines.extend(custom_checks)
+    else:
+        # Default: should exist
+        lines.append(INSPEC_SHOULD_EXIST)
+
+    # Add property checks
+    if properties:
+        property_map = {
+            "mode": lambda v: f"    its('mode') {{ should cmp '{v}' }}",
+            "owner": lambda v: f"    its('owner') {{ should eq '{v}' }}",
+            "group": lambda v: f"    its('group') {{ should eq '{v}' }}",
+            "shell": lambda v: f"    its('shell') {{ should eq '{v}' }}",
+        }
+        for prop, value in properties.items():
+            if prop in property_map:
+                lines.append(property_map[prop](value))
+
+    lines.append(INSPEC_END_INDENT)
+    return lines
+
+
 def _generate_inspec_service_checks(resource_name: str) -> list[str]:
     """
     Generate InSpec checks for service resource.
@@ -627,12 +996,14 @@ def _generate_inspec_service_checks(resource_name: str) -> list[str]:
         List of InSpec check lines.
 
     """
-    return [
-        f"  describe service('{resource_name}') do",
-        "    it { should be_running }",
-        "    it { should be_enabled }",
-        INSPEC_END_INDENT,
-    ]
+    return _generate_inspec_resource_checks(
+        "service",
+        resource_name,
+        custom_checks=[
+            "    it { should be_running }",
+            "    it { should be_enabled }",
+        ],
+    )
 
 
 def _generate_inspec_file_checks(
@@ -649,15 +1020,11 @@ def _generate_inspec_file_checks(
         List of InSpec check lines.
 
     """
-    lines = [f"  describe file('{resource_name}') do", INSPEC_SHOULD_EXIST]
-    if "mode" in properties:
-        lines.append(f"    its('mode') {{ should cmp '{properties['mode']}' }}")
-    if "owner" in properties:
-        lines.append(f"    its('owner') {{ should eq '{properties['owner']}' }}")
-    if "group" in properties:
-        lines.append(f"    its('group') {{ should eq '{properties['group']}' }}")
-    lines.append(INSPEC_END_INDENT)
-    return lines
+    return _generate_inspec_resource_checks(
+        "file",
+        resource_name,
+        properties=properties,
+    )
 
 
 def _generate_inspec_directory_checks(
@@ -674,15 +1041,15 @@ def _generate_inspec_directory_checks(
         List of InSpec check lines.
 
     """
-    lines = [
-        f"  describe file('{resource_name}') do",
-        INSPEC_SHOULD_EXIST,
-        "    it { should be_directory }",
-    ]
-    if "mode" in properties:
-        lines.append(f"    its('mode') {{ should cmp '{properties['mode']}' }}")
-    lines.append(INSPEC_END_INDENT)
-    return lines
+    return _generate_inspec_resource_checks(
+        "file",
+        resource_name,
+        properties=properties,
+        custom_checks=[
+            INSPEC_SHOULD_EXIST,
+            "    it { should be_directory }",
+        ],
+    )
 
 
 def _generate_inspec_user_checks(
@@ -699,11 +1066,11 @@ def _generate_inspec_user_checks(
         List of InSpec check lines.
 
     """
-    lines = [f"  describe user('{resource_name}') do", INSPEC_SHOULD_EXIST]
-    if "shell" in properties:
-        lines.append(f"    its('shell') {{ should eq '{properties['shell']}' }}")
-    lines.append(INSPEC_END_INDENT)
-    return lines
+    return _generate_inspec_resource_checks(
+        "user",
+        resource_name,
+        properties=properties,
+    )
 
 
 def _generate_inspec_group_checks(resource_name: str) -> list[str]:
@@ -717,11 +1084,7 @@ def _generate_inspec_group_checks(resource_name: str) -> list[str]:
         List of InSpec check lines.
 
     """
-    return [
-        f"  describe group('{resource_name}') do",
-        INSPEC_SHOULD_EXIST,
-        INSPEC_END_INDENT,
-    ]
+    return _generate_inspec_resource_checks("group", resource_name)
 
 
 def _generate_inspec_from_resource(