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

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}")
+
+    # Analyze Chef CI patterns
+    patterns = _analyze_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 _analyze_chef_ci_patterns(cookbook_dir: Path) -> dict[str, Any]:
+    """
+    Analyze 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 analyze.
+
+    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

souschef/ci/gitlab_ci.py

@@ -0,0 +1,299 @@
+"""GitLab CI generation from Chef CI/CD patterns."""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+def generate_gitlab_ci_from_chef_ci(
+    cookbook_path: str,
+    project_name: str,
+    enable_cache: bool = True,
+    enable_artifacts: bool = True,
+) -> str:
+    """
+    Generate .gitlab-ci.yml from Chef cookbook CI/CD patterns.
+
+    Analyzes Chef testing tools and generates equivalent GitLab CI stages.
+
+    Args:
+        cookbook_path: Path to Chef cookbook.
+        project_name: GitLab project name.
+        enable_cache: Enable caching for dependencies.
+        enable_artifacts: Enable artifacts for test results.
+
+    Returns:
+        GitLab CI YAML content.
+
+    """
+    # Analyze Chef CI patterns
+    ci_patterns = _analyze_chef_ci_patterns(cookbook_path)
+
+    # Generate CI configuration
+    return _generate_gitlab_ci_yaml(
+        project_name, ci_patterns, enable_cache, enable_artifacts
+    )
+
+
+def _analyze_chef_ci_patterns(cookbook_path: str) -> dict[str, Any]:
+    """
+    Analyze Chef cookbook for CI/CD patterns.
+
+    Args:
+        cookbook_path: Path to Chef cookbook.
+
+    Returns:
+        Dictionary of detected CI patterns.
+
+    """
+    base_path = Path(cookbook_path)
+
+    patterns: dict[str, Any] = {
+        "has_kitchen": (base_path / ".kitchen.yml").exists(),
+        "has_chefspec": (base_path / "spec").exists(),
+        "has_inspec": (base_path / "test" / "integration").exists(),
+        "has_berksfile": (base_path / "Berksfile").exists(),
+        "lint_tools": [],
+        "test_suites": [],
+    }
+
+    # Detect linting tools
+    lint_tools: list[str] = patterns["lint_tools"]
+    if (base_path / ".foodcritic").exists():
+        lint_tools.append("foodcritic")
+    if (base_path / ".cookstyle.yml").exists():
+        lint_tools.append("cookstyle")
+
+    # Parse kitchen.yml for test suites
+    kitchen_file = base_path / ".kitchen.yml"
+    if kitchen_file.exists():
+        try:
+            test_suites: list[str] = patterns["test_suites"]
+            with kitchen_file.open() as f:
+                kitchen_config = yaml.safe_load(f)
+                if kitchen_config and "suites" in kitchen_config:
+                    test_suites.extend(
+                        suite["name"] for suite in kitchen_config["suites"]
+                    )
+        except (yaml.YAMLError, OSError, KeyError, TypeError, AttributeError):
+            # Gracefully handle malformed .kitchen.yml - continue with empty
+            # test suites. Catches: YAML syntax errors, file I/O errors,
+            # missing config keys, type mismatches
+            pass
+
+    return patterns
+
+
+def _build_lint_jobs(ci_patterns: dict[str, Any], enable_artifacts: bool) -> list[str]:
+    """Build lint job configurations."""
+    jobs = []
+    if ci_patterns.get("lint_tools"):
+        lint_commands = []
+        for tool in ci_patterns["lint_tools"]:
+            if tool == "cookstyle":
+                lint_commands.append("  - ansible-lint playbooks/")
+            elif tool == "foodcritic":
+                lint_commands.append("  - yamllint -c .yamllint .")
+
+        if lint_commands:
+            jobs.append(
+                _create_gitlab_job(
+                    "lint:ansible",
+                    "lint",
+                    lint_commands,
+                    allow_failure=False,
+                    artifacts=enable_artifacts,
+                )
+            )
+    return jobs
+
+
+def _build_test_jobs(ci_patterns: dict[str, Any], enable_artifacts: bool) -> list[str]:
+    """Build test job configurations."""
+    jobs = []
+
+    # Unit test job (ChefSpec → Molecule)
+    if ci_patterns.get("has_chefspec"):
+        jobs.append(
+            _create_gitlab_job(
+                "test:unit",
+                "test",
+                ["  - molecule test --scenario-name default"],
+                artifacts=enable_artifacts,
+            )
+        )
+
+    # Integration test jobs (Kitchen → Molecule)
+    if ci_patterns.get("has_kitchen") or ci_patterns.get("has_inspec"):
+        if ci_patterns.get("test_suites"):
+            for suite in ci_patterns["test_suites"]:
+                jobs.append(
+                    _create_gitlab_job(
+                        f"test:integration:{suite}",
+                        "test",
+                        [f"  - molecule test --scenario-name {suite}"],
+                        artifacts=enable_artifacts,
+                    )
+                )
+        else:
+            jobs.append(
+                _create_gitlab_job(
+                    "test:integration",
+                    "test",
+                    ["  - molecule test"],
+                    artifacts=enable_artifacts,
+                )
+            )
+
+    return jobs
+
+
+def _generate_gitlab_ci_yaml(
+    project_name: str,
+    ci_patterns: dict[str, Any],
+    enable_cache: bool,
+    enable_artifacts: bool,
+) -> str:
+    """
+    Generate GitLab CI YAML configuration.
+
+    Args:
+        project_name: Project name.
+        ci_patterns: Detected CI patterns.
+        enable_cache: Enable caching.
+        enable_artifacts: Enable artifacts.
+
+    Returns:
+        GitLab CI YAML content.
+
+    """
+    stages = ["lint", "test", "deploy"]
+    jobs = []
+
+    # Global configuration
+    config_lines = [
+        f"# .gitlab-ci.yml: {project_name}",
+        "# Generated from Chef cookbook CI/CD patterns",
+        "",
+        "image: python:3.11",
+        "",
+        "stages:",
+    ]
+    for stage in stages:
+        config_lines.append(f"  - {stage}")
+    config_lines.append("")
+
+    # Cache configuration
+    if enable_cache:
+        config_lines.extend(
+            [
+                "cache:",
+                "  paths:",
+                "    - .cache/pip",
+                "    - venv/",
+                "",
+            ]
+        )
+
+    # Variables
+    config_lines.extend(
+        [
+            "variables:",
+            "  PIP_CACHE_DIR: $CI_PROJECT_DIR/.cache/pip",
+            "  ANSIBLE_FORCE_COLOR: 'true'",
+            "",
+        ]
+    )
+
+    # Before script
+    config_lines.extend(
+        [
+            "before_script:",
+            "  - python -m venv venv",
+            "  - source venv/bin/activate",
+            "  - pip install --upgrade pip",
+            "  - pip install ansible ansible-lint molecule molecule-docker",
+            "",
+        ]
+    )
+
+    # Build jobs
+    jobs.extend(_build_lint_jobs(ci_patterns, enable_artifacts))
+    jobs.extend(_build_test_jobs(ci_patterns, enable_artifacts))
+
+    # Deploy job
+    jobs.append(
+        _create_gitlab_job(
+            "deploy:production",
+            "deploy",
+            [
+                (
+                    "  - ansible-playbook -i inventory/production "
+                    "playbooks/site.yml --check"
+                ),
+                "  - ansible-playbook -i inventory/production playbooks/site.yml",
+            ],
+            when="manual",
+            only_branches=["main", "master"],
+        )
+    )
+
+    # Combine configuration and jobs
+    config = "\n".join(config_lines) + "\n" + "\n".join(jobs)
+    return config
+
+
+def _create_gitlab_job(
+    name: str,
+    stage: str,
+    script: list[str],
+    allow_failure: bool = False,
+    artifacts: bool = False,
+    when: str | None = None,
+    only_branches: list[str] | None = None,
+) -> str:
+    """
+    Create a GitLab CI job.
+
+    Args:
+        name: Job name.
+        stage: Stage name.
+        script: List of script commands.
+        allow_failure: Allow job failure.
+        artifacts: Enable artifacts.
+        when: When to run (manual, on_success, etc).
+        only_branches: Only run on specific branches.
+
+    Returns:
+        GitLab CI job YAML block.
+
+    """
+    job_lines = [f"{name}:", f"  stage: {stage}", "  script:"]
+    job_lines.extend(script)
+
+    if allow_failure:
+        job_lines.append("  allow_failure: true")
+
+    if artifacts:
+        job_lines.extend(
+            [
+                "  artifacts:",
+                "    reports:",
+                "      junit: test-results/*.xml",
+                "    paths:",
+                "      - test-results/",
+                "    expire_in: 1 week",
+            ]
+        )
+
+    if when:
+        job_lines.append(f"  when: {when}")
+
+    if only_branches:
+        job_lines.append("  only:")
+        for branch in only_branches:
+            job_lines.append(f"    - {branch}")
+
+    job_lines.append("")
+    return "\n".join(job_lines)