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

souschef/assessment.py

@@ -7,6 +7,7 @@ generating migration plans, analyzing dependencies, and validating conversions.
 
 import json
 import re
+from pathlib import Path
 from typing import Any
 
 from souschef.core import METADATA_FILENAME, _normalize_path, _safe_join
@@ -36,18 +37,81 @@ def assess_chef_migration_complexity(
 
     """
     try:
-        # Validate inputs
+        # Validate and parse inputs
         error_msg = _validate_assessment_inputs(
             cookbook_paths, migration_scope, target_platform
         )
         if error_msg:
             return error_msg
 
+        # Process cookbook analysis
+        return _process_cookbook_assessment(
+            cookbook_paths, migration_scope, target_platform
+        )
+
+    except Exception as e:
+        return format_error_with_context(
+            e, "assessing Chef migration complexity", cookbook_paths
+        )
+
+
+def _process_cookbook_assessment(
+    cookbook_paths: str, migration_scope: str, target_platform: str
+) -> str:
+    """Process the cookbook assessment workflow."""
+    # Parse cookbook paths (may be empty if none exist)
+    valid_paths = _parse_cookbook_paths(cookbook_paths)
+
+    # Analyze all cookbooks (handles empty list gracefully)
+    cookbook_assessments, overall_metrics = _analyse_cookbook_metrics(valid_paths)
+
+    # Generate recommendations and reports
+    recommendations = _generate_migration_recommendations_from_assessment(
+        cookbook_assessments, overall_metrics, target_platform
+    )
+    roadmap = _create_migration_roadmap(cookbook_assessments)
+
+    # Format final assessment report
+    return _format_assessment_report(
+        migration_scope,
+        target_platform,
+        overall_metrics,
+        cookbook_assessments,
+        recommendations,
+        roadmap,
+    )
+
+
+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.
+
+    """
+    try:
+        # Validate inputs
+        error_msg = _validate_assessment_inputs(
+            cookbook_paths, migration_scope, target_platform
+        )
+        if error_msg:
+            return {"error": error_msg}
+
         # Parse cookbook paths (may be empty if none exist)
         valid_paths = _parse_cookbook_paths(cookbook_paths)
 
         # Analyze all cookbooks (handles empty list gracefully)
-        cookbook_assessments, overall_metrics = _analyze_cookbook_metrics(valid_paths)
+        cookbook_assessments, overall_metrics = _analyse_cookbook_metrics(valid_paths)
 
         # Generate recommendations and reports
         recommendations = _generate_migration_recommendations_from_assessment(
@@ -55,19 +119,35 @@ def assess_chef_migration_complexity(
         )
         roadmap = _create_migration_roadmap(cookbook_assessments)
 
-        # Format final assessment report
-        return _format_assessment_report(
-            migration_scope,
-            target_platform,
-            overall_metrics,
-            cookbook_assessments,
-            recommendations,
-            roadmap,
-        )
+        return {
+            "migration_scope": migration_scope,
+            "target_platform": target_platform,
+            "overall_metrics": overall_metrics,
+            "cookbook_assessments": cookbook_assessments,
+            "recommendations": recommendations,
+            "roadmap": roadmap,
+            "complexity": _get_overall_complexity_level(overall_metrics),
+            "estimated_hours": overall_metrics.get("estimated_effort_days", 0)
+            * 8,  # Convert days to hours
+        }
+
     except Exception as e:
-        return format_error_with_context(
-            e, "assessing Chef migration complexity", cookbook_paths
-        )
+        return {
+            "error": format_error_with_context(
+                e, "assessing Chef migration complexity", cookbook_paths
+            )
+        }
+
+
+def _get_overall_complexity_level(metrics: dict[str, int]) -> str:
+    """Get overall complexity level based on metrics."""
+    avg_complexity = metrics.get("avg_complexity", 0)
+    if avg_complexity < 30:
+        return "Low"
+    elif avg_complexity < 70:
+        return "Medium"
+    else:
+        return "High"
 
 
 def _validate_migration_plan_inputs(
@@ -214,11 +294,11 @@ def generate_migration_plan(
         return format_error_with_context(e, "generating migration plan", cookbook_paths)
 
 
-def analyze_cookbook_dependencies(
+def analyse_cookbook_dependencies(
     cookbook_path: str, dependency_depth: str = "direct"
 ) -> str:
     """
-    Analyze cookbook dependencies and identify migration order requirements.
+    Analyse cookbook dependencies and identify migration order requirements.
 
     Args:
         cookbook_path: Path to Chef cookbook or cookbooks directory
@@ -245,7 +325,7 @@ def analyze_cookbook_dependencies(
             )
 
         # Analyze dependencies
-        dependency_analysis = _analyze_cookbook_dependencies_detailed(cookbook_path_obj)
+        dependency_analysis = _analyse_cookbook_dependencies_detailed(cookbook_path_obj)
 
         # Determine migration order
         migration_order = _determine_migration_order(dependency_analysis)
@@ -276,7 +356,7 @@ def analyze_cookbook_dependencies(
 {_format_community_cookbooks(dependency_analysis)}
 
 ## Migration Impact Analysis:
-{_analyze_dependency_migration_impact(dependency_analysis)}
+{_analyse_dependency_migration_impact(dependency_analysis)}
 """
     except Exception as e:
         return format_error_with_context(
@@ -459,11 +539,11 @@ def _parse_cookbook_paths(cookbook_paths: str) -> list[Any]:
     return valid_paths
 
 
-def _analyze_cookbook_metrics(
+def _analyse_cookbook_metrics(
     valid_paths: list[Any],
 ) -> tuple[list[Any], dict[str, int]]:
     """
-    Analyze metrics for all cookbooks.
+    Analyse metrics for all cookbooks.
 
     Args:
         valid_paths: List of valid cookbook paths
@@ -576,8 +656,8 @@ def _count_cookbook_artifacts(cookbook_path) -> dict[str, int]:
     }
 
 
-def _analyze_recipe_complexity(cookbook_path) -> dict[str, int]:
-    """Analyze recipe files for resource counts, Ruby blocks, and custom resources."""
+def _analyse_recipe_complexity(cookbook_path) -> dict[str, int]:
+    """Analyse recipe files for resource counts, Ruby blocks, and custom resources."""
     recipes_dir = _safe_join(cookbook_path, "recipes")
     resource_count = 0
     custom_resources = 0
@@ -654,18 +734,21 @@ def _determine_migration_priority(complexity_score: int) -> str:
     return "medium"
 
 
-def _assess_single_cookbook(cookbook_path) -> dict:
+def _assess_single_cookbook(cookbook_path: Path) -> dict:
     """Assess complexity of a single cookbook."""
-    cookbook = _normalize_path(cookbook_path)
+    # cookbook_path is already normalized to a Path object
+    cookbook = cookbook_path
 
     # Collect metrics
     artifact_counts = _count_cookbook_artifacts(cookbook)
-    recipe_complexity = _analyze_recipe_complexity(cookbook)
+    recipe_complexity = _analyse_recipe_complexity(cookbook)
     metrics = {**artifact_counts, **recipe_complexity}
 
     # Calculate complexity and effort
     complexity_score = _calculate_complexity_score(metrics)
-    base_effort = metrics["recipe_count"] * 0.5  # 0.5 days per recipe
+    # More realistic effort: 0.5-2 hours per recipe with AI assistance
+    # Base: 1 hour per recipe = 0.125 days (8-hour day)
+    base_effort = metrics["recipe_count"] * 0.125  # 0.125 days per recipe
     complexity_multiplier = 1 + (complexity_score / 100)
     estimated_effort = round(base_effort * complexity_multiplier, 1)
 
@@ -689,7 +772,7 @@ def _format_overall_metrics(metrics: dict) -> str:
 • Total Resources: {metrics["total_resources"]}
 • Average Complexity: {metrics.get("avg_complexity", 0):.1f}/100
 • Estimated Total Effort: {metrics["estimated_effort_days"]:.1f} person-days
-• Estimated Duration: {int(metrics["estimated_effort_days"] / 5)}-{int(metrics["estimated_effort_days"] / 3)} weeks"""
+• Estimated Duration: {max(1, int(metrics["estimated_effort_days"] / 2))}-{max(2, int(metrics["estimated_effort_days"]))} weeks (with 2-4 parallel engineers)"""
 
 
 def _format_cookbook_assessments(assessments: list) -> str:
@@ -942,7 +1025,7 @@ def _estimate_resource_requirements(metrics: dict, target_platform: str) -> str:
 • **Training:** 2-3 days Ansible/AWX training for team"""
 
 
-def _analyze_cookbook_dependencies_detailed(cookbook_path) -> dict:
+def _analyse_cookbook_dependencies_detailed(cookbook_path) -> dict:
     """Analyze cookbook dependencies in detail."""
     analysis = {
         "cookbook_name": cookbook_path.name,
@@ -1281,8 +1364,8 @@ def _format_community_cookbooks(analysis: dict) -> str:
     )
 
 
-def _analyze_dependency_migration_impact(analysis: dict) -> str:
-    """Analyze migration impact of dependencies."""
+def _analyse_dependency_migration_impact(analysis: dict) -> str:
+    """Analyse migration impact of dependencies."""
     impacts = []
 
     if analysis["community_cookbooks"]:

souschef/ci/__init__.py

@@ -0,0 +1,11 @@
+"""CI/CD pipeline generation from Chef patterns."""
+
+from souschef.ci.github_actions import generate_github_workflow_from_chef_ci
+from souschef.ci.gitlab_ci import generate_gitlab_ci_from_chef_ci
+from souschef.ci.jenkins_pipeline import generate_jenkinsfile_from_chef_ci
+
+__all__ = [
+    "generate_jenkinsfile_from_chef_ci",
+    "generate_gitlab_ci_from_chef_ci",
+    "generate_github_workflow_from_chef_ci",
+]

souschef/ci/github_actions.py

@@ -0,0 +1,379 @@
+"""
+GitHub Actions workflow generation from Chef CI/CD patterns.
+
+Analyzes Chef testing tools (Test Kitchen, ChefSpec, Cookstyle) and
+generates equivalent GitHub Actions workflows with proper job
+configuration and caching.
+"""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+# GitHub Actions constants
+ACTION_CHECKOUT = "actions/checkout@v4"
+ACTION_SETUP_RUBY = "ruby/setup-ruby@v1"
+ACTION_CACHE = "actions/cache@v4"
+ACTION_UPLOAD_ARTIFACT = "actions/upload-artifact@v4"
+
+STEP_NAME_CHECKOUT = "Checkout code"
+STEP_NAME_SETUP_RUBY = "Setup Ruby"
+STEP_NAME_CACHE_GEMS = "Cache gems"
+STEP_NAME_INSTALL_DEPS = "Install dependencies"
+
+GEM_BUNDLE_PATH = "vendor/bundle"
+GEM_CACHE_KEY = "gems-${{ runner.os }}-${{ hashFiles('**/Gemfile.lock') }}"
+GEM_CACHE_RESTORE_KEY = "gems-${{ runner.os }}-"
+
+BUNDLE_INSTALL_CMD = "bundle install --jobs 4 --retry 3"
+
+
+def generate_github_workflow_from_chef_ci(
+    cookbook_path: str,
+    workflow_name: str = "Chef Cookbook CI",
+    enable_cache: bool = True,
+    enable_artifacts: bool = True,
+) -> str:
+    """
+    Generate GitHub Actions workflow from Chef cookbook CI/CD patterns.
+
+    Args:
+        cookbook_path: Path to Chef cookbook directory.
+        workflow_name: Name for the GitHub Actions workflow.
+        enable_cache: Enable caching for Chef dependencies.
+        enable_artifacts: Enable artifacts for test results.
+
+    Returns:
+        GitHub Actions workflow YAML content.
+
+    """
+    cookbook_dir = Path(cookbook_path)
+    if not cookbook_dir.exists():
+        raise FileNotFoundError(f"Cookbook directory not found: {cookbook_path}")
+
+    # Analyse Chef CI patterns
+    patterns = _analyse_chef_ci_patterns(cookbook_dir)
+
+    # Build workflow structure
+    workflow = _build_workflow_structure(
+        workflow_name, patterns, enable_cache, enable_artifacts
+    )
+
+    return yaml.dump(workflow, default_flow_style=False, sort_keys=False)
+
+
+def _analyse_chef_ci_patterns(cookbook_dir: Path) -> dict[str, Any]:
+    """
+    Analyse Chef cookbook for CI/CD patterns and testing configurations.
+
+    This function examines a Chef cookbook directory to detect various
+    testing and linting tools, as well as Test Kitchen configurations
+    including suites and platforms.
+
+    Args:
+        cookbook_dir: Path to the Chef cookbook directory to analyse.
+
+    Returns:
+        Dictionary containing detected patterns with the following keys:
+            - has_kitchen (bool): Whether Test Kitchen is configured
+              (.kitchen.yml exists)
+            - has_chefspec (bool): Whether ChefSpec tests are present
+              (spec/**/*_spec.rb files)
+            - has_cookstyle (bool): Whether Cookstyle is configured
+              (.cookstyle.yml exists)
+            - has_foodcritic (bool): Whether Foodcritic (legacy) is
+              configured (.foodcritic exists)
+            - kitchen_suites (list[str]): Names of Test Kitchen suites
+              found in .kitchen.yml
+            - kitchen_platforms (list[str]): Names of Test Kitchen
+              platforms found in .kitchen.yml
+
+    Note:
+        If .kitchen.yml is malformed or cannot be parsed, the function
+        continues with empty suite and platform lists rather than
+        raising an exception.
+
+    Example:
+        >>> patterns = _analyze_chef_ci_patterns(Path("/path/to/cookbook"))
+        >>> patterns["has_kitchen"]
+        True
+        >>> patterns["kitchen_suites"]
+        ['default', 'integration']
+
+    """
+    patterns: dict[str, Any] = {
+        "has_kitchen": False,
+        "has_chefspec": False,
+        "has_cookstyle": False,
+        "has_foodcritic": False,
+        "kitchen_suites": [],
+        "kitchen_platforms": [],
+    }
+
+    # Check for Test Kitchen
+    kitchen_yml = cookbook_dir / ".kitchen.yml"
+    if kitchen_yml.exists():
+        patterns["has_kitchen"] = True
+        try:
+            with kitchen_yml.open() as f:
+                kitchen_config = yaml.safe_load(f)
+                if kitchen_config:
+                    # Extract suites
+                    suites = kitchen_config.get("suites", [])
+                    if suites:
+                        patterns["kitchen_suites"] = [
+                            s.get("name", "default") for s in suites
+                        ]
+                    # Extract platforms
+                    platforms = kitchen_config.get("platforms", [])
+                    if platforms:
+                        patterns["kitchen_platforms"] = [
+                            p.get("name", "unknown") for p in platforms
+                        ]
+        except (yaml.YAMLError, OSError, KeyError, TypeError, AttributeError):
+            # Gracefully handle malformed .kitchen.yml - continue with empty config
+            # Catches: YAML syntax errors, file I/O errors, missing config keys,
+            # type mismatches in config structure, and missing dict attributes
+            pass
+
+    # Check for ChefSpec
+    spec_dir = cookbook_dir / "spec"
+    if spec_dir.exists() and any(spec_dir.glob("**/*_spec.rb")):
+        patterns["has_chefspec"] = True
+
+    # Check for Cookstyle
+    cookstyle_yml = cookbook_dir / ".cookstyle.yml"
+    if cookstyle_yml.exists():
+        patterns["has_cookstyle"] = True
+
+    # Check for Foodcritic (legacy)
+    if (cookbook_dir / ".foodcritic").exists():
+        patterns["has_foodcritic"] = True
+
+    return patterns
+
+
+def _build_workflow_structure(
+    workflow_name: str,
+    patterns: dict[str, Any],
+    enable_cache: bool,
+    enable_artifacts: bool,
+) -> dict[str, Any]:
+    """
+    Build GitHub Actions workflow structure.
+
+    Args:
+        workflow_name: Workflow name.
+        patterns: Detected Chef CI patterns.
+        enable_cache: Enable caching.
+        enable_artifacts: Enable artifacts.
+
+    Returns:
+        Workflow dictionary structure.
+
+    """
+    workflow: dict[str, Any] = {
+        "name": workflow_name,
+        "on": {
+            "push": {"branches": ["main", "develop"]},
+            "pull_request": {"branches": ["main", "develop"]},
+        },
+        "jobs": {},
+    }
+
+    # Add lint job
+    if patterns["has_cookstyle"] or patterns["has_foodcritic"]:
+        workflow["jobs"]["lint"] = _build_lint_job(patterns, enable_cache)
+
+    # Add unit test job
+    if patterns["has_chefspec"]:
+        workflow["jobs"]["unit-test"] = _build_unit_test_job(enable_cache)
+
+    # Add integration test jobs
+    if patterns["has_kitchen"]:
+        workflow["jobs"]["integration-test"] = _build_integration_test_job(
+            patterns, enable_cache, enable_artifacts
+        )
+
+    return workflow
+
+
+def _build_lint_job(patterns: dict[str, Any], enable_cache: bool) -> dict[str, Any]:
+    """
+    Build lint job configuration.
+
+    Args:
+        patterns: Detected CI patterns.
+        enable_cache: Enable caching.
+
+    Returns:
+        Lint job configuration.
+
+    """
+    job: dict[str, Any] = {
+        "name": "Lint Cookbook",
+        "runs-on": "ubuntu-latest",
+        "steps": [
+            {"name": STEP_NAME_CHECKOUT, "uses": ACTION_CHECKOUT},
+            {
+                "name": STEP_NAME_SETUP_RUBY,
+                "uses": ACTION_SETUP_RUBY,
+                "with": {"ruby-version": "3.2"},
+            },
+        ],
+    }
+
+    if enable_cache:
+        job["steps"].append(
+            {
+                "name": STEP_NAME_CACHE_GEMS,
+                "uses": ACTION_CACHE,
+                "with": {
+                    "path": GEM_BUNDLE_PATH,
+                    "key": GEM_CACHE_KEY,
+                    "restore-keys": GEM_CACHE_RESTORE_KEY,
+                },
+            }
+        )
+
+    job["steps"].extend(
+        [
+            {
+                "name": STEP_NAME_INSTALL_DEPS,
+                "run": BUNDLE_INSTALL_CMD,
+            },
+        ]
+    )
+
+    # Add appropriate lint commands
+    if patterns["has_cookstyle"]:
+        job["steps"].append({"name": "Run Cookstyle", "run": "bundle exec cookstyle"})
+
+    if patterns["has_foodcritic"]:
+        job["steps"].append(
+            {"name": "Run Foodcritic", "run": "bundle exec foodcritic ."}
+        )
+
+    return job
+
+
+def _build_unit_test_job(enable_cache: bool) -> dict[str, Any]:
+    """
+    Build unit test job configuration.
+
+    Args:
+        enable_cache: Enable caching.
+
+    Returns:
+        Unit test job configuration.
+
+    """
+    job: dict[str, Any] = {
+        "name": "Unit Tests (ChefSpec)",
+        "runs-on": "ubuntu-latest",
+        "steps": [
+            {"name": STEP_NAME_CHECKOUT, "uses": ACTION_CHECKOUT},
+            {
+                "name": STEP_NAME_SETUP_RUBY,
+                "uses": ACTION_SETUP_RUBY,
+                "with": {"ruby-version": "3.2"},
+            },
+        ],
+    }
+
+    if enable_cache:
+        job["steps"].append(
+            {
+                "name": STEP_NAME_CACHE_GEMS,
+                "uses": ACTION_CACHE,
+                "with": {
+                    "path": GEM_BUNDLE_PATH,
+                    "key": GEM_CACHE_KEY,
+                    "restore-keys": GEM_CACHE_RESTORE_KEY,
+                },
+            }
+        )
+
+    job["steps"].extend(
+        [
+            {
+                "name": STEP_NAME_INSTALL_DEPS,
+                "run": BUNDLE_INSTALL_CMD,
+            },
+            {"name": "Run ChefSpec tests", "run": "bundle exec rspec"},
+        ]
+    )
+
+    return job
+
+
+def _build_integration_test_job(
+    patterns: dict[str, Any], enable_cache: bool, enable_artifacts: bool
+) -> dict[str, Any]:
+    """
+    Build integration test job configuration.
+
+    Args:
+        patterns: Detected CI patterns.
+        enable_cache: Enable caching.
+        enable_artifacts: Enable artifacts.
+
+    Returns:
+        Integration test job configuration.
+
+    """
+    job: dict[str, Any] = {
+        "name": "Integration Tests (Test Kitchen)",
+        "runs-on": "ubuntu-latest",
+        "strategy": {"matrix": {"suite": patterns["kitchen_suites"] or ["default"]}},
+        "steps": [
+            {"name": STEP_NAME_CHECKOUT, "uses": ACTION_CHECKOUT},
+            {
+                "name": STEP_NAME_SETUP_RUBY,
+                "uses": ACTION_SETUP_RUBY,
+                "with": {"ruby-version": "3.2"},
+            },
+        ],
+    }
+
+    if enable_cache:
+        job["steps"].append(
+            {
+                "name": STEP_NAME_CACHE_GEMS,
+                "uses": ACTION_CACHE,
+                "with": {
+                    "path": GEM_BUNDLE_PATH,
+                    "key": GEM_CACHE_KEY,
+                    "restore-keys": GEM_CACHE_RESTORE_KEY,
+                },
+            }
+        )
+
+    job["steps"].extend(
+        [
+            {
+                "name": STEP_NAME_INSTALL_DEPS,
+                "run": BUNDLE_INSTALL_CMD,
+            },
+            {
+                "name": "Run Test Kitchen",
+                "run": "bundle exec kitchen test ${{ matrix.suite }}",
+            },
+        ]
+    )
+
+    if enable_artifacts:
+        job["steps"].append(
+            {
+                "name": "Upload test results",
+                "uses": ACTION_UPLOAD_ARTIFACT,
+                "if": "always()",
+                "with": {
+                    "name": "kitchen-logs-${{ matrix.suite }}",
+                    "path": ".kitchen/logs/",
+                },
+            }
+        )
+
+    return job