solokit 0.1.1__py3-none-any.whl

solokit/quality/checkers/deployment.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Deployment quality gates checker.
+
+Validates deployment readiness including environment setup, documentation,
+rollback procedures, and orchestrates integration tests and security scans.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+from typing import Any, Union, cast
+
+from solokit.core.command_runner import CommandRunner
+from solokit.core.constants import QUALITY_CHECK_LONG_TIMEOUT
+from solokit.core.logging_config import get_logger
+from solokit.quality.checkers.base import CheckResult, QualityChecker
+
+logger = get_logger(__name__)
+
+
+class DeploymentChecker(QualityChecker):
+    """Deployment readiness validation and orchestration."""
+
+    def __init__(
+        self,
+        work_item: dict[str, Any],
+        config: dict[str, Any],
+        project_root: Path | None = None,
+        runner: CommandRunner | None = None,
+    ):
+        """Initialize deployment checker.
+
+        Args:
+            work_item: Work item dictionary (must be deployment type)
+            config: Deployment quality gate configuration
+            project_root: Project root directory
+            runner: Optional CommandRunner instance (for testing)
+        """
+        super().__init__(config, project_root)
+        self.work_item = work_item
+        self.runner = (
+            runner
+            if runner is not None
+            else CommandRunner(default_timeout=QUALITY_CHECK_LONG_TIMEOUT)
+        )
+
+    def name(self) -> str:
+        """Return checker name."""
+        return "deployment"
+
+    def is_enabled(self) -> bool:
+        """Check if deployment quality gates are enabled."""
+        return bool(self.config.get("enabled", True))
+
+    def run(self) -> CheckResult:
+        """Execute deployment quality gates orchestration.
+
+        Orchestrates:
+        1. Integration tests (via IntegrationChecker)
+        2. Security scans (via SecurityChecker)
+        3. Environment validation
+        4. Deployment documentation validation
+        5. Rollback procedure testing
+
+        Returns:
+            CheckResult with orchestrated deployment validation outcome
+        """
+        start_time = time.time()
+
+        if not self.is_enabled():
+            return self._create_skipped_result("disabled")
+
+        logger.info("Running deployment quality gates...")
+
+        gates: list[dict[str, Any]] = []
+        errors: list[dict[str, Any]] = []
+        warnings: list[dict[str, Any]] = []
+        overall_passed = True
+
+        # Gate 1: All integration tests must pass
+        try:
+            from solokit.quality.checkers.integration import IntegrationChecker
+
+            integration_config = self.config.get("integration_tests", {"enabled": True})
+            integration_checker = IntegrationChecker(
+                self.work_item, integration_config, runner=self.runner
+            )
+
+            # Check if integration checker is applicable
+            if integration_checker.is_enabled():
+                logger.info("Running integration tests gate...")
+                integration_result = integration_checker.run()
+
+                gates.append(
+                    {
+                        "name": "Integration Tests",
+                        "required": True,
+                        "passed": integration_result.passed,
+                        "details": integration_result.info,
+                    }
+                )
+
+                if not integration_result.passed:
+                    overall_passed = False
+                    for error in integration_result.errors:
+                        errors.append({"gate": "Integration Tests", "message": error})
+            else:
+                gates.append(
+                    {
+                        "name": "Integration Tests",
+                        "required": True,
+                        "passed": True,
+                        "details": {"skipped": "not applicable"},
+                    }
+                )
+        except ImportError as e:
+            logger.warning(f"Integration checker not available: {e}")
+            gates.append(
+                {
+                    "name": "Integration Tests",
+                    "required": True,
+                    "passed": True,
+                    "details": {"skipped": "checker not available"},
+                }
+            )
+
+        # Gate 2: Security scans must pass
+        try:
+            from solokit.quality.checkers.security import SecurityChecker
+
+            security_config = self.config.get("security_scans", {"enabled": True})
+            security_checker = SecurityChecker(
+                security_config, project_root=self.project_root, runner=self.runner
+            )
+
+            if security_checker.is_enabled():
+                logger.info("Running security scans gate...")
+                security_result = security_checker.run()
+
+                gates.append(
+                    {
+                        "name": "Security Scans",
+                        "required": True,
+                        "passed": security_result.passed,
+                        "details": security_result.info,
+                    }
+                )
+
+                if not security_result.passed:
+                    overall_passed = False
+                    for error in security_result.errors:
+                        errors.append({"gate": "Security Scans", "message": error})
+            else:
+                gates.append(
+                    {
+                        "name": "Security Scans",
+                        "required": True,
+                        "passed": True,
+                        "details": {"skipped": "disabled"},
+                    }
+                )
+        except ImportError as e:
+            logger.warning(f"Security checker not available: {e}")
+            gates.append(
+                {
+                    "name": "Security Scans",
+                    "required": True,
+                    "passed": True,
+                    "details": {"skipped": "checker not available"},
+                }
+            )
+
+        # Gate 3: Environment must be validated
+        logger.info("Validating deployment environment...")
+        env_passed = self._validate_deployment_environment()
+        gates.append(
+            {
+                "name": "Environment Validation",
+                "required": True,
+                "passed": env_passed,
+            }
+        )
+        if not env_passed:
+            overall_passed = False
+            errors.append(
+                {
+                    "gate": "Environment Validation",
+                    "message": "Deployment environment validation failed",
+                }
+            )
+
+        # Gate 4: Deployment documentation complete
+        logger.info("Validating deployment documentation...")
+        docs_passed = self._validate_deployment_documentation()
+        gates.append(
+            {
+                "name": "Deployment Documentation",
+                "required": True,
+                "passed": docs_passed,
+            }
+        )
+        if not docs_passed:
+            overall_passed = False
+            errors.append(
+                {
+                    "gate": "Deployment Documentation",
+                    "message": "Deployment documentation incomplete",
+                }
+            )
+
+        # Gate 5: Rollback procedure tested
+        logger.info("Checking rollback testing...")
+        rollback_tested = self._check_rollback_tested()
+        gates.append({"name": "Rollback Tested", "required": True, "passed": rollback_tested})
+        if not rollback_tested:
+            overall_passed = False
+            errors.append(
+                {
+                    "gate": "Rollback Tested",
+                    "message": "Rollback procedure not tested",
+                }
+            )
+
+        execution_time = time.time() - start_time
+
+        return CheckResult(
+            checker_name=self.name(),
+            passed=overall_passed,
+            status="passed" if overall_passed else "failed",
+            errors=cast(list[Union[dict[str, Any], str]], errors),
+            warnings=cast(list[Union[dict[str, Any], str]], warnings),
+            info={"gates": gates},
+            execution_time=execution_time,
+        )
+
+    def _validate_deployment_environment(self) -> bool:
+        """Validate deployment environment is ready.
+
+        Checks:
+        - Target environment extracted from work item specification
+        - Environment validator available and passes validation
+        - Falls back to True if validator not available
+
+        Returns:
+            True if environment validation passes, False otherwise
+        """
+        try:
+            from solokit.quality.env_validator import EnvironmentValidator
+
+            # Parse target environment from work item
+            # Try to extract from spec, fallback to "staging"
+            spec = self.work_item.get("specification", "")
+            environment = "staging"  # Default fallback
+
+            # Simple pattern matching for common environment declarations
+            env_match = re.search(r"environment[:\s]+(\w+)", spec.lower())
+            if env_match:
+                environment = env_match.group(1)
+
+            logger.info(f"Validating deployment environment: {environment}")
+            validator = EnvironmentValidator(environment)
+            passed, _ = validator.validate_all()
+
+            return passed
+        except ImportError:
+            # If environment_validator not available, return True
+            logger.debug("Environment validator module not available, skipping validation")
+            return True
+
+    def _validate_deployment_documentation(self) -> bool:
+        """Validate deployment documentation is complete.
+
+        Required sections in work item specification:
+        - deployment procedure
+        - rollback procedure
+        - smoke tests
+        - monitoring & alerting
+
+        Returns:
+            True if all required sections present, False otherwise
+        """
+        spec = self.work_item.get("specification", "")
+
+        required_sections = [
+            "deployment procedure",
+            "rollback procedure",
+            "smoke tests",
+            "monitoring & alerting",
+        ]
+
+        missing_sections = []
+        for section in required_sections:
+            if section.lower() not in spec.lower():
+                missing_sections.append(section)
+                logger.warning(f"Missing required documentation section: {section}")
+
+        if missing_sections:
+            logger.error(
+                f"Deployment documentation incomplete. Missing: {', '.join(missing_sections)}"
+            )
+            return False
+
+        return True
+
+    def _check_rollback_tested(self) -> bool:
+        """Check if rollback procedure has been tested.
+
+        NOTE: Framework stub - Check deployment history for rollback test
+        When implemented, this should:
+        1. Query deployment history/logs
+        2. Check if rollback has been tested in staging/test environment
+        3. Verify rollback completed successfully
+
+        Returns:
+            True by default to allow framework operation
+        """
+        # NOTE: Framework stub - Returns True to allow operation
+        # In production, implement actual rollback testing verification
+        logger.debug("Rollback testing check: Framework stub, returning True")
+        return True

solokit/quality/checkers/documentation.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Documentation validation checker.
+
+Validates CHANGELOG updates, docstrings, and README currency.
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+from typing import Any, Union, cast
+
+from solokit.core.command_runner import CommandRunner
+from solokit.core.constants import (
+    GIT_STANDARD_TIMEOUT,
+    QUALITY_CHECK_STANDARD_TIMEOUT,
+)
+from solokit.core.logging_config import get_logger
+from solokit.quality.checkers.base import CheckResult, QualityChecker
+
+logger = get_logger(__name__)
+
+
+class DocumentationChecker(QualityChecker):
+    """Documentation requirements validation."""
+
+    def __init__(
+        self,
+        config: dict[str, Any],
+        project_root: Path | None = None,
+        work_item: dict[str, Any] | None = None,
+        runner: CommandRunner | None = None,
+    ):
+        """Initialize documentation checker.
+
+        Args:
+            config: Documentation configuration
+            project_root: Project root directory
+            work_item: Work item dictionary (optional, for README check)
+            runner: Optional CommandRunner instance (for testing)
+        """
+        super().__init__(config, project_root)
+        self.runner = (
+            runner
+            if runner is not None
+            else CommandRunner(default_timeout=QUALITY_CHECK_STANDARD_TIMEOUT)
+        )
+        self.work_item = work_item or {}
+
+    def name(self) -> str:
+        """Return checker name."""
+        return "documentation"
+
+    def is_enabled(self) -> bool:
+        """Check if documentation validation is enabled."""
+        return bool(self.config.get("enabled", True))
+
+    def run(self) -> CheckResult:
+        """Run documentation validation."""
+        start_time = time.time()
+
+        if not self.is_enabled():
+            return self._create_skipped_result()
+
+        logger.info("Running documentation validation")
+
+        checks = []
+        passed = True
+
+        # Check CHANGELOG updated
+        if self.config.get("check_changelog", False):
+            changelog_passed = self._check_changelog_updated()
+            checks.append({"name": "CHANGELOG updated", "passed": changelog_passed})
+            if not changelog_passed:
+                passed = False
+
+        # Check docstrings for Python
+        if self.config.get("check_docstrings", False):
+            docstrings_passed = self._check_python_docstrings()
+            checks.append({"name": "Docstrings present", "passed": docstrings_passed})
+            if not docstrings_passed:
+                passed = False
+
+        # Check README current
+        if self.config.get("check_readme", False):
+            readme_passed = self._check_readme_current()
+            checks.append({"name": "README current", "passed": readme_passed})
+            if not readme_passed:
+                passed = False
+
+        execution_time = time.time() - start_time
+
+        errors = []
+        for check in checks:
+            if not check["passed"]:
+                errors.append({"message": f"{check['name']} check failed"})
+
+        return CheckResult(
+            checker_name=self.name(),
+            passed=passed,
+            status="passed" if passed else "failed",
+            errors=cast(list[Union[dict[str, Any], str]], errors),
+            warnings=[],
+            info={"checks": checks},
+            execution_time=execution_time,
+        )
+
+    def _check_changelog_updated(self) -> bool:
+        """Check if CHANGELOG was updated in the current branch."""
+        # Get the current branch name
+        result = self.runner.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"], timeout=GIT_STANDARD_TIMEOUT
+        )
+        if not result.success:
+            logger.debug("Could not check CHANGELOG: git not available")
+            return True  # Skip check if git not available
+
+        current_branch = result.stdout.strip()
+
+        # Don't check if we're on main/master
+        if current_branch in ["main", "master"]:
+            logger.debug("On main/master branch, skipping CHANGELOG check")
+            return True
+
+        # Check if CHANGELOG.md was modified in any commit on this branch
+        result = self.runner.run(
+            ["git", "log", "--name-only", "--pretty=format:", "main..HEAD"],
+            timeout=GIT_STANDARD_TIMEOUT,
+        )
+
+        if result.success and "CHANGELOG.md" in result.stdout:
+            logger.debug("CHANGELOG updated in branch")
+            return True
+        else:
+            logger.debug("CHANGELOG not updated in branch")
+            return False
+
+    def _check_python_docstrings(self) -> bool:
+        """Check if Python functions have docstrings."""
+        # Only check if this is a Python project
+        if (
+            not (self.project_root / "pyproject.toml").exists()
+            and not (self.project_root / "setup.py").exists()
+        ):
+            return True
+
+        result = self.runner.run(
+            [sys.executable, "-m", "pydocstyle", "--count"], timeout=QUALITY_CHECK_STANDARD_TIMEOUT
+        )
+
+        # If pydocstyle not available or timeout, skip check
+        if result.timed_out or result.returncode == -1:
+            logger.debug("pydocstyle not available, skipping docstring check")
+            return True
+
+        # If no issues found, return True
+        return result.returncode == 0
+
+    def _check_readme_current(self) -> bool:
+        """Check if README was updated (optional check)."""
+        result = self.runner.run(
+            ["git", "diff", "--name-only", "HEAD~1..HEAD"], timeout=GIT_STANDARD_TIMEOUT
+        )
+
+        if not result.success:
+            logger.debug("Could not check README: git not available")
+            return True  # Skip check if git not available
+
+        changed_files = result.stdout.strip().split("\n")
+        readme_updated = any("README" in f.upper() for f in changed_files)
+
+        if readme_updated:
+            logger.debug("README updated")
+        else:
+            logger.debug("README not updated")
+
+        return readme_updated

solokit/quality/checkers/formatting.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Code formatting checker.
+
+Runs formatters like black, prettier, etc.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, Union, cast
+
+from solokit.core.command_runner import CommandRunner
+from solokit.core.constants import QUALITY_CHECK_VERY_LONG_TIMEOUT
+from solokit.core.logging_config import get_logger
+from solokit.quality.checkers.base import CheckResult, QualityChecker
+
+logger = get_logger(__name__)
+
+
+class FormattingChecker(QualityChecker):
+    """Code formatting validation."""
+
+    def __init__(
+        self,
+        config: dict[str, Any],
+        project_root: Path | None = None,
+        language: str | None = None,
+        auto_fix: bool | None = None,
+        runner: CommandRunner | None = None,
+    ):
+        """Initialize formatting checker.
+
+        Args:
+            config: Formatting configuration
+            project_root: Project root directory
+            language: Programming language (python, javascript, typescript)
+            auto_fix: Whether to automatically format (overrides config)
+            runner: Optional CommandRunner instance (for testing)
+        """
+        super().__init__(config, project_root)
+        self.runner = (
+            runner
+            if runner is not None
+            else CommandRunner(default_timeout=QUALITY_CHECK_VERY_LONG_TIMEOUT)
+        )
+        self.language = language or self._detect_language()
+        self.auto_fix = auto_fix if auto_fix is not None else self.config.get("auto_fix", False)
+
+    def name(self) -> str:
+        """Return checker name."""
+        return "formatting"
+
+    def is_enabled(self) -> bool:
+        """Check if formatting is enabled."""
+        return bool(self.config.get("enabled", True))
+
+    def _detect_language(self) -> str:
+        """Detect primary project language."""
+        if (self.project_root / "pyproject.toml").exists() or (
+            self.project_root / "setup.py"
+        ).exists():
+            return "python"
+        elif (self.project_root / "package.json").exists():
+            if (self.project_root / "tsconfig.json").exists():
+                return "typescript"
+            return "javascript"
+        return "python"  # default
+
+    def run(self) -> CheckResult:
+        """Run formatting checks."""
+        start_time = time.time()
+
+        if not self.is_enabled():
+            return self._create_skipped_result()
+
+        logger.info(f"Running formatting for {self.language}")
+
+        # Get formatting command for language
+        commands = self.config.get("commands", {})
+        command = commands.get(self.language)
+        if not command:
+            logger.warning(f"No formatting command configured for language: {self.language}")
+            return self._create_skipped_result(reason=f"no command for {self.language}")
+
+        # Add appropriate flags based on auto_fix and language
+        if self.language == "python":
+            if not self.auto_fix:
+                command += " --check"
+        elif self.language in ["javascript", "typescript"]:
+            if self.auto_fix:
+                command += " --write"
+            else:
+                command += " --check"
+
+        # Run formatter
+        result = self.runner.run(command.split(), timeout=QUALITY_CHECK_VERY_LONG_TIMEOUT)
+
+        execution_time = time.time() - start_time
+
+        if result.timed_out:
+            required = self.config.get("required", False)
+            if required:
+                return CheckResult(
+                    checker_name=self.name(),
+                    passed=False,
+                    status="failed",
+                    errors=[{"message": "Formatting timed out"}],
+                    warnings=[],
+                    info={"reason": "timeout"},
+                    execution_time=execution_time,
+                )
+            return CheckResult(
+                checker_name=self.name(),
+                passed=True,
+                status="skipped",
+                errors=[],
+                warnings=[],
+                info={"reason": "timeout"},
+                execution_time=execution_time,
+            )
+
+        # Tool not found
+        if result.returncode == -1:
+            required = self.config.get("required", False)
+            if required:
+                return CheckResult(
+                    checker_name=self.name(),
+                    passed=False,
+                    status="failed",
+                    errors=[{"message": "Required formatting tool not found"}],
+                    warnings=[],
+                    info={"reason": "tool not found"},
+                    execution_time=execution_time,
+                )
+            return self._create_skipped_result(reason="formatting tool not available")
+
+        passed = result.returncode == 0
+
+        errors = []
+        if not passed:
+            errors.append(
+                {
+                    "message": "Code formatting issues found",
+                    "output": result.stdout[:500] if result.stdout else "",
+                }
+            )
+
+        return CheckResult(
+            checker_name=self.name(),
+            passed=passed,
+            status="passed" if passed else "failed",
+            errors=cast(list[Union[dict[str, Any], str]], errors),
+            warnings=[],
+            info={
+                "formatted": self.auto_fix,
+                "output": result.stdout[:1000] if result.stdout else "",
+            },
+            execution_time=execution_time,
+        )