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

souschef/parsers/metadata.py

@@ -0,0 +1,211 @@
+"""Chef cookbook metadata parser."""
+
+import re
+
+from souschef.core.constants import (
+    ERROR_FILE_NOT_FOUND,
+    ERROR_IS_DIRECTORY,
+    ERROR_PERMISSION_DENIED,
+    METADATA_FILENAME,
+)
+from souschef.core.path_utils import _normalize_path, _safe_join
+
+
+def read_cookbook_metadata(path: str) -> str:
+    """
+    Parse Chef cookbook metadata.rb file.
+
+    Args:
+        path: Path to the metadata.rb file.
+
+    Returns:
+        Formatted string with extracted metadata.
+
+    """
+    try:
+        file_path = _normalize_path(path)
+        content = file_path.read_text(encoding="utf-8")
+
+        metadata = _extract_metadata(content)
+
+        if not metadata:
+            return f"Warning: No metadata found in {path}"
+
+        return _format_metadata(metadata)
+
+    except ValueError as e:
+        return f"Error: {e}"
+    except FileNotFoundError:
+        return ERROR_FILE_NOT_FOUND.format(path=path)
+    except IsADirectoryError:
+        return ERROR_IS_DIRECTORY.format(path=path)
+    except PermissionError:
+        return ERROR_PERMISSION_DENIED.format(path=path)
+    except Exception as e:
+        return f"An error occurred: {e}"
+
+
+def _scan_cookbook_directory(
+    cookbook_path, dir_name: str
+) -> tuple[str, list[str]] | None:
+    """
+    Scan a single cookbook directory for files.
+
+    Args:
+        cookbook_path: Path to the cookbook root.
+        dir_name: Name of the subdirectory to scan.
+
+    Returns:
+        Tuple of (dir_name, files) if directory exists and has files, None otherwise.
+
+    """
+    dir_path = _safe_join(cookbook_path, dir_name)
+    if not dir_path.exists() or not dir_path.is_dir():
+        return None
+
+    files = [f.name for f in dir_path.iterdir() if f.is_file()]
+    return (dir_name, files) if files else None
+
+
+def _collect_cookbook_structure(cookbook_path) -> dict[str, list[str]]:
+    """
+    Collect all standard cookbook directories and their files.
+
+    Args:
+        cookbook_path: Path to the cookbook root.
+
+    Returns:
+        Dictionary mapping directory names to file lists.
+
+    """
+    structure = {}
+    common_dirs = [
+        "recipes",
+        "attributes",
+        "templates",
+        "files",
+        "resources",
+        "providers",
+        "libraries",
+        "definitions",
+    ]
+
+    for dir_name in common_dirs:
+        result = _scan_cookbook_directory(cookbook_path, dir_name)
+        if result:
+            structure[result[0]] = result[1]
+
+    # Check for metadata.rb
+    metadata_path = _safe_join(cookbook_path, METADATA_FILENAME)
+    if metadata_path.exists():
+        structure["metadata"] = [METADATA_FILENAME]
+
+    return structure
+
+
+def list_cookbook_structure(path: str) -> str:
+    """
+    List the structure of a Chef cookbook directory.
+
+    Args:
+        path: Path to the cookbook root directory.
+
+    Returns:
+        Formatted string showing the cookbook structure.
+
+    """
+    try:
+        cookbook_path = _normalize_path(path)
+
+        if not cookbook_path.is_dir():
+            return f"Error: {path} is not a directory"
+
+        structure = _collect_cookbook_structure(cookbook_path)
+
+        if not structure:
+            return f"Warning: No standard cookbook structure found in {path}"
+
+        return _format_cookbook_structure(structure)
+
+    except PermissionError:
+        return ERROR_PERMISSION_DENIED.format(path=path)
+    except Exception as e:
+        return f"An error occurred: {e}"
+
+
+def _extract_metadata(content: str) -> dict[str, str | list[str]]:
+    """
+    Extract metadata fields from cookbook content.
+
+    Args:
+        content: Raw content of metadata.rb file.
+
+    Returns:
+        Dictionary of extracted metadata fields.
+
+    """
+    metadata: dict[str, str | list[str]] = {}
+    patterns = {
+        "name": r"name\s+['\"]([^'\"]+)['\"]",
+        "maintainer": r"maintainer\s+['\"]([^'\"]+)['\"]",
+        "version": r"version\s+['\"]([^'\"]+)['\"]",
+        "description": r"description\s+['\"]([^'\"]+)['\"]",
+        "license": r"license\s+['\"]([^'\"]+)['\"]",
+    }
+
+    for key, pattern in patterns.items():
+        match = re.search(pattern, content)
+        if match:
+            metadata[key] = match.group(1)
+
+    depends = re.findall(r"depends\s+['\"]([^'\"]+)['\"]", content)
+    if depends:
+        metadata["depends"] = depends
+
+    supports = re.findall(r"supports\s+['\"]([^'\"]+)['\"]", content)
+    if supports:
+        metadata["supports"] = supports
+
+    return metadata
+
+
+def _format_metadata(metadata: dict[str, str | list[str]]) -> str:
+    """
+    Format metadata dictionary as a readable string.
+
+    Args:
+        metadata: Dictionary of metadata fields.
+
+    Returns:
+        Formatted string representation.
+
+    """
+    result = []
+    for key, value in metadata.items():
+        if isinstance(value, list):
+            result.append(f"{key}: {', '.join(value)}")
+        else:
+            result.append(f"{key}: {value}")
+
+    return "\n".join(result)
+
+
+def _format_cookbook_structure(structure: dict[str, list[str]]) -> str:
+    """
+    Format cookbook structure as a readable string.
+
+    Args:
+        structure: Dictionary mapping directory names to file lists.
+
+    Returns:
+        Formatted string representation.
+
+    """
+    result = []
+    for dir_name, files in structure.items():
+        result.append(f"{dir_name}/")
+        for file_name in sorted(files):
+            result.append(f"  {file_name}")
+        result.append("")
+
+    return "\n".join(result).rstrip()

souschef/parsers/recipe.py

@@ -0,0 +1,200 @@
+"""Chef recipe parser."""
+
+import re
+from typing import Any
+
+from souschef.core.constants import (
+    ERROR_FILE_NOT_FOUND,
+    ERROR_IS_DIRECTORY,
+    ERROR_PERMISSION_DENIED,
+)
+from souschef.core.path_utils import _normalize_path
+from souschef.parsers.template import _strip_ruby_comments
+
+# Maximum length for resource body content in regex matching
+# Prevents ReDoS attacks from extremely large resource blocks
+MAX_RESOURCE_BODY_LENGTH = 15000
+
+# Maximum length for conditional expressions and branches
+MAX_CONDITION_LENGTH = 200
+
+# Maximum length for case statement body content
+MAX_CASE_BODY_LENGTH = 2000
+
+
+def parse_recipe(path: str) -> str:
+    """
+    Parse a Chef recipe file and extract resources.
+
+    Args:
+        path: Path to the recipe (.rb) file.
+
+    Returns:
+        Formatted string with extracted Chef resources and their properties.
+
+    """
+    try:
+        file_path = _normalize_path(path)
+        content = file_path.read_text(encoding="utf-8")
+
+        resources = _extract_resources(content)
+
+        if not resources:
+            return f"Warning: No Chef resources found in {path}"
+
+        return _format_resources(resources)
+
+    except ValueError as e:
+        return f"Error: {e}"
+    except FileNotFoundError:
+        return ERROR_FILE_NOT_FOUND.format(path=path)
+    except IsADirectoryError:
+        return ERROR_IS_DIRECTORY.format(path=path)
+    except PermissionError:
+        return ERROR_PERMISSION_DENIED.format(path=path)
+    except Exception as e:
+        return f"An error occurred: {e}"
+
+
+def _extract_resources(content: str) -> list[dict[str, str]]:
+    """
+    Extract Chef resources from recipe content.
+
+    Args:
+        content: Raw content of recipe file.
+
+    Returns:
+        List of dictionaries containing resource information.
+
+    """
+    resources = []
+    # Strip comments first
+    clean_content = _strip_ruby_comments(content)
+
+    # Match Chef resource declarations with various patterns:
+    # 1. Standard: package 'nginx' do ... end
+    # 2. With parentheses: package('nginx') do ... end
+    # 3. Multi-line strings: package 'nginx' do\n  content <<-EOH\n  ...\n  EOH\nend
+    # Use a more robust pattern that avoids matching 'end' keywords within the body
+    # Pattern breakdown: match any char that doesn't start spelling 'end' at line start
+    # This prevents catastrophic backtracking on large files
+    pattern = (
+        r"(\w+)\s+(?:\()?['\"]([^'\"]+)['\"](?:\))?\s+do"
+        rf"((?:[^e]|e(?:[^n]|n(?:[^d]|\d))|(?!^)e(?:n(?:d))){{0,{MAX_RESOURCE_BODY_LENGTH}}}?)"
+        r"^end"
+    )
+
+    for match in re.finditer(pattern, clean_content, re.DOTALL | re.MULTILINE):
+        resource_type = match.group(1)
+        resource_name = match.group(2)
+        resource_body = match.group(3)
+
+        resource = {
+            "type": resource_type,
+            "name": resource_name,
+        }
+
+        # Extract action
+        action_match = re.search(r"action\s+:(\w+)", resource_body)
+        if action_match:
+            resource["action"] = action_match.group(1)
+
+        # Extract common properties
+        properties = {}
+        for prop_match in re.finditer(r"(\w+)\s+['\"]([^'\"]+)['\"]", resource_body):
+            prop_name = prop_match.group(1)
+            if prop_name not in ["action"]:
+                properties[prop_name] = prop_match.group(2)
+
+        if properties:
+            resource["properties"] = str(properties)
+
+        resources.append(resource)
+
+    return resources
+
+
+def _extract_conditionals(content: str) -> list[dict[str, Any]]:
+    """
+    Extract Ruby conditionals from recipe code.
+
+    Args:
+        content: Ruby code content.
+
+    Returns:
+        List of dictionaries with conditional information.
+
+    """
+    conditionals = []
+
+    # Match case/when statements
+    # Use explicit non-'end' matching to avoid ReDoS
+    case_pattern = (
+        rf"case\s+([^\n]{{1,{MAX_CONDITION_LENGTH}}})\n"
+        rf"([^e]|e[^n]|en[^d]){{0,{MAX_CASE_BODY_LENGTH}}}^end"
+    )
+    for match in re.finditer(case_pattern, content, re.DOTALL | re.MULTILINE):
+        case_expr = match.group(1).strip()
+        case_body = match.group(2)
+        when_clauses = re.findall(
+            rf"when\s+['\"]?([^'\"\n]{{1,{MAX_CONDITION_LENGTH}}})['\"]?\s*\n",
+            case_body,
+        )
+        conditionals.append(
+            {
+                "type": "case",
+                "expression": case_expr,
+                "branches": when_clauses,
+            }
+        )
+
+    # Match if/elsif/else statements
+    if_pattern = r"if\s+([^\n]+)\n?"
+    for match in re.finditer(if_pattern, content):
+        condition = match.group(1).strip()
+        if condition and not condition.startswith(("elsif", "end")):
+            conditionals.append(
+                {
+                    "type": "if",
+                    "condition": condition,
+                }
+            )
+
+    # Match unless statements
+    unless_pattern = r"unless\s+([^\n]+)\n?"
+    for match in re.finditer(unless_pattern, content):
+        condition = match.group(1).strip()
+        conditionals.append(
+            {
+                "type": "unless",
+                "condition": condition,
+            }
+        )
+
+    return conditionals
+
+
+def _format_resources(resources: list[dict[str, Any]]) -> str:
+    """
+    Format resources list as a readable string.
+
+    Args:
+        resources: List of resource dictionaries.
+
+    Returns:
+        Formatted string representation.
+
+    """
+    result = []
+    for i, resource in enumerate(resources, 1):
+        if i > 1:
+            result.append("")
+        result.append(f"Resource {i}:")
+        result.append(f"  Type: {resource['type']}")
+        result.append(f"  Name: {resource['name']}")
+        if "action" in resource:
+            result.append(f"  Action: {resource['action']}")
+        if "properties" in resource:
+            result.append(f"  Properties: {resource['properties']}")
+
+    return "\n".join(result)

souschef/parsers/resource.py

@@ -0,0 +1,170 @@
+"""Chef custom resource parser."""
+
+import json
+import re
+from typing import Any
+
+from souschef.core.constants import (
+    ERROR_FILE_NOT_FOUND,
+    ERROR_IS_DIRECTORY,
+    ERROR_PERMISSION_DENIED,
+)
+from souschef.core.path_utils import _normalize_path
+from souschef.parsers.template import _strip_ruby_comments
+
+
+def parse_custom_resource(path: str) -> str:
+    """
+    Parse a Chef custom resource or LWRP file.
+
+    Args:
+        path: Path to the custom resource (.rb) file.
+
+    Returns:
+        JSON string with extracted properties, actions, and metadata.
+
+    """
+    try:
+        file_path = _normalize_path(path)
+        content = file_path.read_text(encoding="utf-8")
+
+        # Determine resource type
+        resource_type = "custom_resource" if "property" in content else "lwrp"
+
+        # Extract properties/attributes
+        properties = _extract_resource_properties(content)
+
+        # Extract actions
+        actions_info = _extract_resource_actions(content)
+
+        result = {
+            "resource_file": str(file_path),
+            "resource_name": file_path.stem,
+            "resource_type": resource_type,
+            "properties": properties,
+            "actions": actions_info["actions"],
+            "default_action": actions_info["default_action"],
+        }
+
+        return json.dumps(result, indent=2)
+
+    except FileNotFoundError:
+        return ERROR_FILE_NOT_FOUND.format(path=path)
+    except IsADirectoryError:
+        return ERROR_IS_DIRECTORY.format(path=path)
+    except PermissionError:
+        return ERROR_PERMISSION_DENIED.format(path=path)
+    except UnicodeDecodeError:
+        return f"Error: Unable to decode {path} as UTF-8 text"
+    except Exception as e:
+        return f"An error occurred: {e}"
+
+
+def _extract_common_property_options(options: str, info: dict[str, Any]) -> None:
+    """
+    Extract common property options (default, required, name_property).
+
+    Args:
+        options: Options string from property/attribute definition.
+        info: Dictionary to update with extracted options.
+
+    """
+    # Extract name_property / name_attribute
+    if "name_property: true" in options or "name_attribute: true" in options:
+        info["name_property"] = True
+
+    # Extract default value
+    default_match = re.search(r"default:\s*([^,\n]+)", options)
+    if default_match:
+        info["default"] = default_match.group(1).strip()
+
+    # Extract required
+    if "required: true" in options:
+        info["required"] = True
+
+
+def _extract_resource_properties(content: str) -> list[dict[str, Any]]:
+    """
+    Extract property definitions from custom resource.
+
+    Args:
+        content: Raw content of custom resource file.
+
+    Returns:
+        List of dictionaries containing property information.
+
+    """
+    properties = []
+    # Strip comments
+    clean_content = _strip_ruby_comments(content)
+
+    # Match modern property syntax: property :name, Type, options
+    # Updated to handle multi-line definitions and complex types like [true, false]
+    property_pattern = (
+        r"property\s+:(\w+),\s*([^,\n\[]+(?:\[[^\]]+\])?),?\s*([^\n]*?)(?:\n|$)"
+    )
+    for match in re.finditer(property_pattern, clean_content, re.MULTILINE):
+        prop_info: dict[str, Any] = {
+            "name": match.group(1),
+            "type": match.group(2).strip(),
+        }
+        _extract_common_property_options(match.group(3) or "", prop_info)
+        properties.append(prop_info)
+
+    # Match LWRP attribute syntax: attribute :name, kind_of: Type
+    attribute_pattern = r"attribute\s+:(\w+)(?:,\s*([^\n]+))?\n?"
+    for match in re.finditer(attribute_pattern, content, re.MULTILINE):
+        attr_options = match.group(2) or ""
+        attr_info: dict[str, Any] = {
+            "name": match.group(1),
+            "type": "Any",  # Default type
+        }
+
+        # Extract type from kind_of
+        kind_of_match = re.search(r"kind_of:\s*(\w+)", attr_options)
+        if kind_of_match:
+            attr_info["type"] = kind_of_match.group(1)
+
+        _extract_common_property_options(attr_options, attr_info)
+        properties.append(attr_info)
+
+    return properties
+
+
+def _extract_resource_actions(content: str) -> dict[str, Any]:
+    """
+    Extract action definitions from custom resource.
+
+    Args:
+        content: Raw content of custom resource file.
+
+    Returns:
+        Dictionary with actions list and default action.
+
+    """
+    result: dict[str, Any] = {
+        "actions": [],
+        "default_action": None,
+    }
+
+    # Extract modern action blocks: action :name do ... end
+    action_pattern = r"action\s+:(\w+)\s+do"
+    for match in re.finditer(action_pattern, content):
+        action_name = match.group(1)
+        if action_name not in result["actions"]:
+            result["actions"].append(action_name)
+
+    # Extract LWRP-style actions declaration: actions :create, :drop
+    actions_decl = re.search(r"actions\s+([^\n]+)\n?", content)
+    if actions_decl:
+        action_symbols = re.findall(r":(\w+)", actions_decl.group(1))
+        for action in action_symbols:
+            if action not in result["actions"]:
+                result["actions"].append(action)
+
+    # Extract default action
+    default_match = re.search(r"default_action\s+:(\w+)", content)
+    if default_match:
+        result["default_action"] = default_match.group(1)
+
+    return result