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

souschef/cli.py

@@ -11,6 +11,10 @@ from typing import NoReturn
 
 import click
 
+from souschef.profiling import (
+    generate_cookbook_performance_report,
+    profile_function,
+)
 from souschef.server import (
     convert_inspec_to_test,
     convert_resource_to_task,
@@ -425,6 +429,92 @@ def _output_result(result: str, output_format: str) -> None:
         _output_text_format(result)
 
 
+@cli.command()
+@click.argument("cookbook_path", type=click.Path(exists=True))
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(),
+    help="Save report to file instead of printing to stdout",
+)
+def profile(cookbook_path: str, output: str | None) -> None:
+    """
+    Profile cookbook parsing performance and generate optimization report.
+
+    COOKBOOK_PATH: Path to the Chef cookbook to profile
+
+    This command analyzes the performance of parsing all cookbook components
+    (recipes, attributes, resources, templates) and provides recommendations
+    for optimization.
+    """
+    try:
+        click.echo(f"Profiling cookbook: {cookbook_path}")
+        click.echo("This may take a moment for large cookbooks...")
+
+        report = generate_cookbook_performance_report(cookbook_path)
+        report_text = str(report)
+
+        if output:
+            Path(output).write_text(report_text)
+            click.echo(f"✓ Performance report saved to: {output}")
+        else:
+            click.echo(report_text)
+
+    except Exception as e:
+        click.echo(f"Error profiling cookbook: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument(
+    "operation",
+    type=click.Choice(["recipe", "attributes", "resource", "template"]),
+)
+@click.argument("path", type=click.Path(exists=True))
+@click.option(
+    "--detailed",
+    is_flag=True,
+    help="Show detailed function call statistics",
+)
+def profile_operation(operation: str, path: str, detailed: bool) -> None:
+    """
+    Profile a single parsing operation in detail.
+
+    OPERATION: Type of operation to profile
+    PATH: Path to the file to parse
+
+    This command profiles a single parsing operation and shows
+    execution time, memory usage, and optionally detailed function statistics.
+    """
+    operation_map = {
+        "recipe": parse_recipe,
+        "attributes": parse_attributes,
+        "resource": parse_custom_resource,
+        "template": parse_template,
+    }
+
+    func = operation_map[operation]
+
+    try:
+        click.echo(f"Profiling {operation} parsing: {path}")
+
+        if detailed:
+            from souschef.profiling import detailed_profile_function
+
+            _, profile_result = detailed_profile_function(func, path)
+            click.echo(str(profile_result))
+            if profile_result.function_stats.get("top_functions"):
+                click.echo("\nDetailed Function Statistics:")
+                click.echo(profile_result.function_stats["top_functions"])
+        else:
+            _, profile_result = profile_function(func, path)
+            click.echo(str(profile_result))
+
+    except Exception as e:
+        click.echo(f"Error profiling operation: {e}", err=True)
+        sys.exit(1)
+
+
 def main() -> NoReturn:
     """Run the CLI."""
     cli()

souschef/converters/playbook.py

@@ -1441,8 +1441,40 @@ def _extract_chef_guards(resource: dict[str, str], raw_content: str) -> dict[str
     return guards
 
 
+def _is_opening_delimiter(char: str, in_quotes: bool) -> bool:
+    """Check if character is an opening delimiter."""
+    return char == "{" and not in_quotes
+
+
+def _is_closing_delimiter(char: str, in_quotes: bool) -> bool:
+    """Check if character is a closing delimiter."""
+    return char == "}" and not in_quotes
+
+
+def _is_quote_character(char: str) -> bool:
+    """Check if character is a quote."""
+    return char in ['"', "'"]
+
+
+def _should_split_here(char: str, in_quotes: bool, in_block: int) -> bool:
+    """Determine if we should split at this comma."""
+    return char == "," and not in_quotes and in_block == 0
+
+
 def _split_guard_array_parts(array_content: str) -> list[str]:
-    """Split array content by commas, respecting quotes and blocks."""
+    """
+    Split array content by commas, respecting quotes and blocks.
+
+    Handles Chef guard arrays like: ['test -f /file', { block }, "string"]
+    Tracks quote state and brace nesting to avoid splitting inside strings or blocks.
+
+    Args:
+        array_content: Raw array content string
+
+    Returns:
+        List of array parts split by commas
+
+    """
     parts = []
     current_part = ""
     in_quotes = False
@@ -1450,24 +1482,30 @@ def _split_guard_array_parts(array_content: str) -> list[str]:
     quote_char = None
 
     for char in array_content:
-        if char in ['"', "'"] and not in_block:
+        # Handle quote transitions
+        if _is_quote_character(char) and not in_block:
             if not in_quotes:
                 in_quotes = True
                 quote_char = char
             elif char == quote_char:
                 in_quotes = False
                 quote_char = None
-        elif char == "{" and not in_quotes:
+
+        # Handle block nesting
+        elif _is_opening_delimiter(char, in_quotes):
             in_block += 1
-        elif char == "}" and not in_quotes:
+        elif _is_closing_delimiter(char, in_quotes):
             in_block -= 1
-        elif char == "," and not in_quotes and in_block == 0:
+
+        # Handle splits at commas
+        elif _should_split_here(char, in_quotes, in_block):
             parts.append(current_part.strip())
             current_part = ""
             continue
 
         current_part += char
 
+    # Add final part if not empty
     if current_part.strip():
         parts.append(current_part.strip())
 

souschef/converters/resource.py

@@ -2,10 +2,14 @@
 
 import ast
 import json
+from collections.abc import Callable
 from typing import Any
 
 from souschef.core.constants import ACTION_TO_STATE, RESOURCE_MAPPINGS
 
+# Type alias for parameter builder functions
+ParamBuilder = Callable[[str, str, dict[str, Any]], dict[str, Any]]
+
 
 def _parse_properties(properties_str: str) -> dict[str, Any]:
     """
@@ -87,6 +91,39 @@ def _get_service_params(resource_name: str, action: str) -> dict[str, Any]:
     return params
 
 
+def _get_template_file_params(resource_name: str, action: str) -> dict[str, Any]:
+    """Get parameters for template resources."""
+    params = {
+        "src": resource_name,
+        "dest": resource_name.replace(".erb", ""),
+    }
+    if action == "create":
+        params["mode"] = "0644"
+    return params
+
+
+def _get_regular_file_params(resource_name: str, action: str) -> dict[str, Any]:
+    """Get parameters for regular file resources."""
+    params: dict[str, Any] = {"path": resource_name}
+    if action == "create":
+        params["state"] = "file"
+        params["mode"] = "0644"
+    else:
+        params["state"] = ACTION_TO_STATE.get(action, action)
+    return params
+
+
+def _get_directory_params(resource_name: str, action: str) -> dict[str, Any]:
+    """Get parameters for directory resources."""
+    params: dict[str, Any] = {
+        "path": resource_name,
+        "state": "directory",
+    }
+    if action == "create":
+        params["mode"] = "0755"
+    return params
+
+
 def _get_file_params(
     resource_name: str, action: str, resource_type: str
 ) -> dict[str, Any]:
@@ -102,34 +139,84 @@ def _get_file_params(
         Dictionary of Ansible file parameters.
 
     """
-    params: dict[str, Any] = {}
-
     if resource_type == "template":
-        params["src"] = resource_name
-        params["dest"] = resource_name.replace(".erb", "")
-        if action == "create":
-            params["mode"] = "0644"
+        return _get_template_file_params(resource_name, action)
     elif resource_type == "file":
-        params["path"] = resource_name
-        if action == "create":
-            params["state"] = "file"
-            params["mode"] = "0644"
-        else:
-            params["state"] = ACTION_TO_STATE.get(action, action)
+        return _get_regular_file_params(resource_name, action)
     elif resource_type == "directory":
-        params["path"] = resource_name
-        params["state"] = "directory"
-        if action == "create":
-            params["mode"] = "0755"
+        return _get_directory_params(resource_name, action)
+    return {}
+
+
+def _get_package_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """Build parameters for package resources."""
+    return {"name": resource_name, "state": ACTION_TO_STATE.get(action, action)}
+
+
+def _get_execute_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """Build parameters for execute/bash resources."""
+    return {"cmd": resource_name}
+
+
+def _get_user_group_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """Build parameters for user/group resources."""
+    return {"name": resource_name, "state": ACTION_TO_STATE.get(action, "present")}
+
+
+def _get_remote_file_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """Build parameters for remote_file resources."""
+    params = {"dest": resource_name}
+    # Map Chef properties to Ansible parameters
+    prop_mappings = {
+        "source": "url",
+        "mode": "mode",
+        "owner": "owner",
+        "group": "group",
+        "checksum": "checksum",
+    }
+    for chef_prop, ansible_param in prop_mappings.items():
+        if chef_prop in props:
+            params[ansible_param] = props[chef_prop]
+    return params
 
+
+def _get_default_params(resource_name: str, action: str) -> dict[str, Any]:
+    """Build default parameters for unknown resource types."""
+    params = {"name": resource_name}
+    if action in ACTION_TO_STATE:
+        params["state"] = ACTION_TO_STATE[action]
     return params
 
 
+# Resource type to parameter builder mappings
+RESOURCE_PARAM_BUILDERS: dict[str, ParamBuilder | str] = {
+    "package": _get_package_params,
+    "service": "service",  # Uses _get_service_params
+    "systemd_unit": "service",
+    "template": "file",  # Uses _get_file_params
+    "file": "file",
+    "directory": "file",
+    "execute": _get_execute_params,
+    "bash": _get_execute_params,
+    "user": _get_user_group_params,
+    "group": _get_user_group_params,
+    "remote_file": _get_remote_file_params,
+}
+
+
 def _convert_chef_resource_to_ansible(
     resource_type: str, resource_name: str, action: str, properties: str
 ) -> dict[str, Any]:
     """
-    Convert Chef resource to Ansible task dictionary.
+    Convert Chef resource to Ansible task dictionary using data-driven approach.
 
     Args:
         resource_type: The Chef resource type.
@@ -149,46 +236,56 @@ def _convert_chef_resource_to_ansible(
         "name": f"{action.capitalize()} {resource_type} {resource_name}",
     }
 
-    # Build module parameters based on resource type
-    module_params: dict[str, Any] = {}
-
-    # Parse properties if provided
+    # Parse properties
     props = _parse_properties(properties)
 
-    if resource_type == "package":
-        module_params["name"] = resource_name
-        module_params["state"] = ACTION_TO_STATE.get(action, action)
-    elif resource_type in ["service", "systemd_unit"]:
-        module_params = _get_service_params(resource_name, action)
-    elif resource_type in ["template", "file", "directory"]:
-        module_params = _get_file_params(resource_name, action, resource_type)
-    elif resource_type in ["execute", "bash"]:
-        module_params["cmd"] = resource_name
+    # Build module parameters using appropriate builder
+    module_params = _build_module_params(resource_type, resource_name, action, props)
+
+    # Add special task-level flags for execute/bash resources
+    if resource_type in ["execute", "bash"]:
         task["changed_when"] = "false"
-    elif resource_type in ["user", "group"]:
-        module_params["name"] = resource_name
-        module_params["state"] = ACTION_TO_STATE.get(action, "present")
-    elif resource_type == "remote_file":
-        module_params["dest"] = resource_name
-        if "source" in props:
-            module_params["url"] = props["source"]
-        if "mode" in props:
-            module_params["mode"] = props["mode"]
-        if "owner" in props:
-            module_params["owner"] = props["owner"]
-        if "group" in props:
-            module_params["group"] = props["group"]
-        if "checksum" in props:
-            module_params["checksum"] = props["checksum"]
-    else:
-        module_params["name"] = resource_name
-        if action in ACTION_TO_STATE:
-            module_params["state"] = ACTION_TO_STATE[action]
 
     task[ansible_module] = module_params
     return task
 
 
+def _build_module_params(
+    resource_type: str, resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """
+    Build Ansible module parameters based on resource type.
+
+    Args:
+        resource_type: The Chef resource type.
+        resource_name: The resource name.
+        action: The Chef action.
+        props: Parsed properties dictionary.
+
+    Returns:
+        Dictionary of Ansible module parameters.
+
+    """
+    # Look up the parameter builder for this resource type
+    builder = RESOURCE_PARAM_BUILDERS.get(resource_type)
+
+    if builder is None:
+        # Unknown resource type - use default builder
+        return _get_default_params(resource_name, action)
+
+    if isinstance(builder, str):
+        # Special handler reference (service/file)
+        if builder == "service":
+            return _get_service_params(resource_name, action)
+        elif builder == "file":
+            return _get_file_params(resource_name, action, resource_type)
+        # This shouldn't happen, but handle gracefully
+        return _get_default_params(resource_name, action)
+
+    # Call the parameter builder function
+    return builder(resource_name, action, props)
+
+
 def _format_yaml_value(value: Any) -> str:
     """Format a value for YAML output."""
     if isinstance(value, str):

souschef/core/__init__.py

@@ -38,6 +38,18 @@ from souschef.core.constants import (
     REGEX_WORD_SYMBOLS,
     RESOURCE_MAPPINGS,
 )
+from souschef.core.errors import (
+    ChefFileNotFoundError,
+    ConversionError,
+    InvalidCookbookError,
+    ParseError,
+    SousChefError,
+    ValidationError,
+    format_error_with_context,
+    validate_cookbook_structure,
+    validate_directory_exists,
+    validate_file_exists,
+)
 from souschef.core.path_utils import _normalize_path, _safe_join
 from souschef.core.ruby_utils import _normalize_ruby_value
 from souschef.core.validation import (
@@ -55,4 +67,14 @@ __all__ = [
     "ValidationEngine",
     "ValidationLevel",
     "ValidationResult",
+    "SousChefError",
+    "ChefFileNotFoundError",
+    "InvalidCookbookError",
+    "ParseError",
+    "ConversionError",
+    "ValidationError",
+    "validate_file_exists",
+    "validate_directory_exists",
+    "validate_cookbook_structure",
+    "format_error_with_context",
 ]