pre-commit-check.py

#!/usr/bin/env python
"""
Pre-commit quality check script for the RAG system.

This script runs a comprehensive suite of quality checks including:
- Code formatting (ruff format)
- Linting (ruff check)
- Type checking (pyright)
- Security checks (bandit)
- Unit tests (pytest)
- Test coverage
"""

import argparse
import subprocess
import sys
from pathlib import Path
from typing import Optional

# Set UTF-8 encoding for Windows console
if sys.platform == "win32":
    import io

    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")


class Colors:
    """ANSI color codes for terminal output."""

    HEADER = "\033[95m"
    OKBLUE = "\033[94m"
    OKCYAN = "\033[96m"
    OKGREEN = "\033[92m"
    WARNING = "\033[93m"
    FAIL = "\033[91m"
    ENDC = "\033[0m"
    BOLD = "\033[1m"
    UNDERLINE = "\033[4m"


class QualityChecker:
    """Main quality checker class."""

    def __init__(self, fix: bool = False, skip_tests: bool = False, verbose: bool = False):
        """
        Initialize the quality checker.

        Args:
            fix: Whether to automatically fix issues
            skip_tests: Whether to skip running tests
            verbose: Whether to show verbose output
        """
        self.fix = fix
        self.skip_tests = skip_tests
        self.verbose = verbose
        self.results: list[tuple[str, bool, Optional[str]]] = []

    def print_header(self, message: str) -> None:
        """Print a formatted header."""
        print(f"\n{Colors.HEADER}{Colors.BOLD}{'=' * 70}{Colors.ENDC}")
        print(f"{Colors.HEADER}{Colors.BOLD}{message}{Colors.ENDC}")
        print(f"{Colors.HEADER}{Colors.BOLD}{'=' * 70}{Colors.ENDC}\n")

    def print_step(self, message: str) -> None:
        """Print a step message."""
        print(f"{Colors.OKCYAN}> {message}...{Colors.ENDC}")

    def print_success(self, message: str) -> None:
        """Print a success message."""
        print(f"{Colors.OKGREEN}+ {message}{Colors.ENDC}")

    def print_warning(self, message: str) -> None:
        """Print a warning message."""
        print(f"{Colors.WARNING}! {message}{Colors.ENDC}")

    def print_error(self, message: str) -> None:
        """Print an error message."""
        print(f"{Colors.FAIL}x {message}{Colors.ENDC}")

    def run_command(
        self, cmd: list[str], check_name: str, success_msg: str, error_msg: str
    ) -> bool:
        """
        Run a command and track results.

        Args:
            cmd: Command to run
            check_name: Name of the check
            success_msg: Message to show on success
            error_msg: Message to show on error

        Returns:
            True if command succeeded, False otherwise
        """
        self.print_step(check_name)

        try:
            result = subprocess.run(cmd, capture_output=True, text=True, check=False)

            if result.returncode == 0:
                self.print_success(success_msg)
                self.results.append((check_name, True, None))
                return True
            else:
                self.print_error(error_msg)
                error_output = result.stdout + result.stderr
                if self.verbose and error_output:
                    print(f"\n{error_output}\n")
                self.results.append((check_name, False, error_output))
                return False

        except FileNotFoundError:
            self.print_warning(f"Tool not found: {cmd[0]}")
            self.results.append((check_name, False, f"Tool not found: {cmd[0]}"))
            return False
        except Exception as e:
            self.print_error(f"Error running {check_name}: {str(e)}")
            self.results.append((check_name, False, str(e)))
            return False

    def check_ruff_format(self) -> bool:
        """Check code formatting with ruff."""
        if self.fix:
            cmd = ["python", "-m", "ruff", "format", "rag_system", "tests"]
            return self.run_command(
                cmd,
                "Code formatting (ruff)",
                "Code formatted successfully",
                "Code formatting issues found",
            )
        else:
            cmd = ["python", "-m", "ruff", "format", "--check", "rag_system", "tests"]
            return self.run_command(
                cmd,
                "Code formatting check (ruff)",
                "Code formatting is correct",
                "Code formatting issues found (run with --fix to auto-format)",
            )

    def check_ruff_lint(self) -> bool:
        """Check code style and quality with ruff."""
        if self.fix:
            cmd = ["python", "-m", "ruff", "check", "--fix", "rag_system", "tests"]
            return self.run_command(
                cmd,
                "Linting (ruff)",
                "Linting issues fixed successfully",
                "Linting issues found",
            )
        else:
            cmd = ["python", "-m", "ruff", "check", "rag_system", "tests"]
            return self.run_command(
                cmd,
                "Linting check (ruff)",
                "No linting issues found",
                "Linting issues found (run with --fix to auto-fix)",
            )

    def check_pyright(self) -> bool:
        """Check type hints with pyright."""
        cmd = ["python", "-m", "pyright", "rag_system"]
        return self.run_command(
            cmd, "Type checking (pyright)", "Type checking passed", "Type checking issues found"
        )

    def check_bandit(self) -> bool:
        """Check security issues with bandit."""
        cmd = [
            "python",
            "-m",
            "bandit",
            "-r",
            "rag_system",
            "-ll",  # Only report medium and high severity
            "-f",
            "screen",
        ]
        return self.run_command(
            cmd, "Security check (bandit)", "No security issues found", "Security issues found"
        )

    def run_tests(self) -> bool:
        """Run unit tests with pytest."""
        cmd = [
            "python",
            "-m",
            "pytest",
            "tests/",
            "-v",
            "--tb=short",
            "--cov=rag_system",
            "--cov-report=term-missing",
            "--cov-report=html",
            "--cov-fail-under=80",
        ]
        return self.run_command(
            cmd,
            "Unit tests (pytest)",
            "All tests passed with sufficient coverage",
            "Tests failed or coverage is below 80%",
        )

    def check_requirements(self) -> bool:
        """Check if requirements.txt is up to date."""
        self.print_step("Checking requirements.txt")

        try:
            # Check if requirements.txt exists
            req_file = Path("requirements.txt")
            if not req_file.exists():
                self.print_warning("requirements.txt not found")
                self.results.append(("Requirements check", False, "File not found"))
                return False

            # Check if it's not empty
            content = req_file.read_text()
            if not content.strip():
                self.print_warning("requirements.txt is empty")
                self.results.append(("Requirements check", False, "File is empty"))
                return False

            self.print_success("requirements.txt exists and is not empty")
            self.results.append(("Requirements check", True, None))
            return True

        except Exception as e:
            self.print_error(f"Error checking requirements: {str(e)}")
            self.results.append(("Requirements check", False, str(e)))
            return False

    def check_git_status(self) -> bool:
        """Check git status for uncommitted changes."""
        self.print_step("Checking git status")

        try:
            result = subprocess.run(
                ["git", "status", "--porcelain"], capture_output=True, text=True, check=False
            )

            if result.returncode != 0:
                self.print_warning("Not a git repository or git not available")
                self.results.append(("Git status check", False, "Git not available"))
                return False

            changes = result.stdout.strip()
            if changes:
                self.print_warning(f"Uncommitted changes found:\n{changes}")
                self.results.append(("Git status check", True, "Changes found"))
            else:
                self.print_success("No uncommitted changes")
                self.results.append(("Git status check", True, None))

            return True

        except Exception as e:
            self.print_warning(f"Error checking git status: {str(e)}")
            self.results.append(("Git status check", False, str(e)))
            return False

    def print_summary(self) -> bool:
        """Print summary of all checks."""
        self.print_header("QUALITY CHECK SUMMARY")

        passed = sum(1 for _, success, _ in self.results if success)
        failed = len(self.results) - passed

        print(f"Total checks: {len(self.results)}")
        print(f"{Colors.OKGREEN}Passed: {passed}{Colors.ENDC}")
        print(f"{Colors.FAIL}Failed: {failed}{Colors.ENDC}\n")

        if failed > 0:
            print(f"{Colors.FAIL}Failed checks:{Colors.ENDC}")
            for name, success, error in self.results:
                if not success:
                    print(f"  {Colors.FAIL}✗ {name}{Colors.ENDC}")
                    if self.verbose and error:
                        print(f"    {error[:200]}...")

        print()

        if failed == 0:
            self.print_success("All quality checks passed! ✨")
            print(f"\n{Colors.OKGREEN}Your code is ready to commit!{Colors.ENDC}\n")
            return True
        else:
            self.print_error("Some quality checks failed!")
            print(f"\n{Colors.FAIL}Please fix the issues before committing.{Colors.ENDC}")
            if not self.fix:
                print(
                    f"{Colors.WARNING}Tip: Run with --fix to automatically fix some issues.{Colors.ENDC}\n"
                )
            return False

    def run_all_checks(self) -> bool:
        """Run all quality checks."""
        self.print_header("RAG SYSTEM - PRE-COMMIT QUALITY CHECKS")

        # Check requirements first
        self.check_requirements()

        # Check git status
        self.check_git_status()

        # Code formatting with ruff
        self.check_ruff_format()

        # Linting with ruff
        self.check_ruff_lint()

        # Type checking with pyright
        self.check_pyright()

        # Security
        self.check_bandit()

        # Tests (if not skipped)
        if not self.skip_tests:
            self.run_tests()
        else:
            self.print_warning("Tests skipped (--skip-tests flag)")

        # Print summary
        return self.print_summary()


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Run pre-commit quality checks for the RAG system",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python pre-commit-check.py                    # Run all checks
  python pre-commit-check.py --fix              # Run checks and auto-fix issues
  python pre-commit-check.py --skip-tests       # Skip running tests
  python pre-commit-check.py --verbose          # Show detailed output
  python pre-commit-check.py --fix --verbose    # Fix issues with detailed output
        """,
    )

    parser.add_argument(
        "--fix",
        action="store_true",
        help="Automatically fix issues where possible (formatting, imports)",
    )

    parser.add_argument(
        "--skip-tests",
        action="store_true",
        help="Skip running unit tests (faster for quick checks)",
    )

    parser.add_argument(
        "--verbose", "-v", action="store_true", help="Show verbose output including error details"
    )

    args = parser.parse_args()

    # Create checker and run all checks
    checker = QualityChecker(fix=args.fix, skip_tests=args.skip_tests, verbose=args.verbose)

    success = checker.run_all_checks()

    # Exit with appropriate code
    sys.exit(0 if success else 1)


if __name__ == "__main__":
    main()