claude-dev-env 1.0.0

package/hooks/validators/file_structure_checks.py

@@ -0,0 +1,182 @@
+"""File structure validation checks for pre-PR validation."""
+
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+
+EXCLUDED_DIRS = {".venv", "venv", "node_modules", ".git"}
+
+# Django requires empty __init__.py in these directories for module discovery
+DJANGO_REQUIRED_INIT_DIRS = {
+    "migrations",
+    "management",
+    "commands",
+    "templatetags",
+}
+
+# Files that indicate a directory is a Django app
+DJANGO_APP_INDICATORS = {
+    "apps.py",
+    "models.py",
+    "views.py",
+    "admin.py",
+    "settings.py",
+    "urls.py",
+}
+
+
+@dataclass(frozen=True)
+class Violation:
+    """Represents a validation violation."""
+
+    file: str
+    line: int
+    message: str
+
+
+def _normalize_path(path: Path, project_root: Path) -> str:
+    """
+    Convert Path to normalized string with forward slashes.
+
+    Args:
+        path: Path to normalize
+        project_root: Project root for relative path calculation
+
+    Returns:
+        Normalized path string with forward slashes
+    """
+    relative = path.relative_to(project_root)
+    return relative.as_posix()
+
+
+def _should_exclude_path(path: Path, project_root: Path) -> bool:
+    """Check if path should be excluded from validation."""
+    try:
+        relative = path.relative_to(project_root)
+        return any(part in EXCLUDED_DIRS for part in relative.parts)
+    except ValueError:
+        return False
+
+
+def check_multiple_requirements_txt(project_root: Path) -> List[Violation]:
+    """
+    Check for multiple requirements.txt files in project.
+
+    Args:
+        project_root: Root directory of the project
+
+    Returns:
+        List of violations found (empty if single or no requirements.txt)
+    """
+    requirements_files: List[Path] = []
+
+    for req_file in project_root.rglob("requirements.txt"):
+        if not _should_exclude_path(req_file, project_root):
+            requirements_files.append(req_file)
+
+    if len(requirements_files) <= 1:
+        return []
+
+    extra_files = [
+        _normalize_path(f, project_root)
+        for f in requirements_files
+        if f != project_root / "requirements.txt"
+    ]
+
+    message = (
+        f"Multiple requirements.txt files found. "
+        f"Project should have exactly one requirements.txt at root. "
+        f"Extra files: {', '.join(extra_files)}"
+    )
+
+    return [Violation(file="requirements.txt", line=1, message=message)]
+
+
+def _is_django_required_init(init_file: Path) -> bool:
+    """Check if __init__.py is in a Django-required directory or Django app."""
+    parent = init_file.parent
+    parent_name = parent.name
+
+    # Check if in known Django-required directory
+    if parent_name in DJANGO_REQUIRED_INIT_DIRS:
+        return True
+
+    # Check if this is a Django app directory (contains apps.py, models.py, etc.)
+    for indicator in DJANGO_APP_INDICATORS:
+        if (parent / indicator).exists():
+            return True
+
+    return False
+
+
+def check_empty_init_files(project_root: Path) -> List[Violation]:
+    """
+    Check for empty __init__.py files that serve no purpose.
+
+    Excludes Django-required directories (migrations, management, commands, templatetags)
+    which need empty __init__.py for module discovery.
+
+    Args:
+        project_root: Root directory of the project
+
+    Returns:
+        List of violations found (one per empty __init__.py)
+    """
+    violations: List[Violation] = []
+
+    for init_file in project_root.rglob("__init__.py"):
+        if _should_exclude_path(init_file, project_root):
+            continue
+
+        # Skip Django-required empty inits
+        if _is_django_required_init(init_file):
+            continue
+
+        content = init_file.read_text(encoding="utf-8")
+        if not content.strip():
+            relative_path = _normalize_path(init_file, project_root)
+            message = (
+                "Empty __init__.py file serves no purpose. "
+                "Either add exports/initialization or delete the file."
+            )
+            violations.append(Violation(file=relative_path, line=1, message=message))
+
+    return violations
+
+
+def main(args: List[str]) -> None:
+    """
+    Run all file structure checks and print violations.
+
+    Args:
+        args: Command line arguments (expects project root path)
+
+    Exits:
+        0 if all checks pass, 1 if violations found or invalid usage
+    """
+    if len(args) == 0:
+        print("Usage: python file_structure_checks.py <project_root>")
+        sys.exit(1)
+
+    project_root = Path(args[0])
+    if not project_root.exists():
+        print(f"Error: Project root does not exist: {project_root}")
+        sys.exit(1)
+
+    all_violations: List[Violation] = []
+
+    all_violations.extend(check_multiple_requirements_txt(project_root))
+    all_violations.extend(check_empty_init_files(project_root))
+
+    if all_violations:
+        for violation in all_violations:
+            print(f"{violation.file}:{violation.line}: {violation.message}")
+        sys.exit(1)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

package/hooks/validators/git_checks.py

@@ -0,0 +1,107 @@
+"""Git and GitHub validation checks for pre-push review."""
+
+import json
+import subprocess
+import sys
+from dataclasses import dataclass
+from typing import List
+
+
+SUBPROCESS_TIMEOUT_SECONDS = 30
+
+
+@dataclass
+class Violation:
+    """Represents a validation violation."""
+    file: str
+    line: int
+    message: str
+
+
+def get_current_branch() -> str:
+    """Get the current git branch name."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=SUBPROCESS_TIMEOUT_SECONDS,
+        )
+        return result.stdout.strip()
+    except (FileNotFoundError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
+        return ""
+
+
+def check_draft_pr_state() -> List[Violation]:
+    """
+    Check that PR is in draft state.
+
+    Returns empty list if:
+    - No PR exists for current branch
+    - gh CLI not available
+    - PR is in draft state
+
+    Returns violation if:
+    - PR is not in draft state
+    """
+    branch = get_current_branch()
+    if not branch:
+        return []
+
+    try:
+        pr_info = subprocess.run(
+            ["gh", "pr", "list", "--head", branch, "--json", "number,isDraft"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=SUBPROCESS_TIMEOUT_SECONDS,
+        )
+    except FileNotFoundError:
+        return []
+    except subprocess.CalledProcessError:
+        return []
+    except subprocess.TimeoutExpired:
+        return []
+
+    if not pr_info.stdout.strip():
+        return []
+
+    try:
+        pr_data = json.loads(pr_info.stdout)
+    except json.JSONDecodeError:
+        return []
+
+    if not pr_data:
+        return []
+
+    is_draft = pr_data[0].get("isDraft", False)
+
+    if is_draft:
+        return []
+
+    return [
+        Violation(
+            file="",
+            line=0,
+            message="PR must be in draft state before pushing. Run: gh pr ready --undo",
+        )
+    ]
+
+
+def main() -> None:
+    """Run all git checks and exit with appropriate code."""
+    violations: List[Violation] = []
+
+    violations.extend(check_draft_pr_state())
+
+    if violations:
+        for violation in violations:
+            print(violation.message)
+        sys.exit(1)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/validators/health_check.py

@@ -0,0 +1,214 @@
+"""Health checks for validator availability and status.
+
+Provides:
+- Validator file existence checks
+- Dependency availability checks
+- Version tracking
+"""
+
+import hashlib
+import subprocess
+import sys
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional
+
+
+VALIDATOR_FILES = [
+    "python_style_checks.py",
+    "test_safety_checks.py",
+    "file_structure_checks.py",
+    "react_checks.py",
+    "git_checks.py",
+    "comment_checks.py",
+]
+
+
+@dataclass(frozen=True)
+class ValidatorHealth:
+    """Health status of a single validator."""
+
+    name: str
+    healthy: bool
+    error: Optional[str] = None
+    last_modified: Optional[datetime] = None
+
+
+@dataclass(frozen=True)
+class SystemHealth:
+    """Overall system health status."""
+
+    all_healthy: bool
+    validators: Dict[str, ValidatorHealth]
+    python_version: str
+    optional_tools: Dict[str, bool]
+
+
+def check_validator_exists(validator_path: Path) -> ValidatorHealth:
+    """Check if a validator file exists and is readable.
+
+    Args:
+        validator_path: Path to validator Python file
+
+    Returns:
+        ValidatorHealth with status
+    """
+    name = validator_path.stem
+
+    if not validator_path.exists():
+        return ValidatorHealth(
+            name=name,
+            healthy=False,
+            error=f"Validator not found: {validator_path}",
+        )
+
+    try:
+        validator_path.read_text(encoding="utf-8")
+        mtime = datetime.fromtimestamp(validator_path.stat().st_mtime)
+        return ValidatorHealth(
+            name=name,
+            healthy=True,
+            last_modified=mtime,
+        )
+    except (IOError, OSError, PermissionError) as error:
+        return ValidatorHealth(
+            name=name,
+            healthy=False,
+            error=f"Cannot read validator: {error}",
+        )
+
+
+def check_all_validators(validators_dir: Path) -> Dict[str, ValidatorHealth]:
+    """Check health of all required validators.
+
+    Args:
+        validators_dir: Directory containing validator files
+
+    Returns:
+        Dict mapping validator names to health status
+    """
+    results: Dict[str, ValidatorHealth] = {}
+
+    for validator_file in VALIDATOR_FILES:
+        validator_path = validators_dir / validator_file
+        health = check_validator_exists(validator_path)
+        results[health.name] = health
+
+    return results
+
+
+def check_optional_tool(tool_name: str) -> bool:
+    """Check if an optional tool is available.
+
+    Args:
+        tool_name: Name of tool to check (ruff, mypy, isort)
+
+    Returns:
+        True if tool is available
+    """
+    try:
+        result = subprocess.run(
+            [tool_name, "--version"],
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        return False
+
+
+def get_validator_version(validators_dir: Optional[Path] = None) -> str:
+    """Get a version string for the validator suite.
+
+    Args:
+        validators_dir: Optional override for validators directory
+
+    Returns:
+        Version string based on file hashes
+    """
+    if validators_dir is None:
+        validators_dir = Path(__file__).parent
+    hasher = hashlib.md5()
+
+    for validator_file in sorted(VALIDATOR_FILES):
+        validator_path = validators_dir / validator_file
+        if validator_path.exists():
+            content = validator_path.read_bytes()
+            hasher.update(content)
+
+    return hasher.hexdigest()[:8]
+
+
+def get_system_health(validators_dir: Optional[Path] = None) -> SystemHealth:
+    """Get complete system health status.
+
+    Args:
+        validators_dir: Optional override for validators directory
+
+    Returns:
+        SystemHealth with all status information
+    """
+    if validators_dir is None:
+        validators_dir = Path(__file__).parent
+
+    validators = check_all_validators(validators_dir)
+    all_healthy = all(v.healthy for v in validators.values())
+
+    optional_tools = {
+        "ruff": check_optional_tool("ruff"),
+        "mypy": check_optional_tool("mypy"),
+        "isort": check_optional_tool("isort"),
+    }
+
+    return SystemHealth(
+        all_healthy=all_healthy,
+        validators=validators,
+        python_version=sys.version,
+        optional_tools=optional_tools,
+    )
+
+
+def print_health_report(health: SystemHealth) -> None:
+    """Print a formatted health report.
+
+    Args:
+        health: SystemHealth to report
+    """
+    print("=" * 60)
+    print("VALIDATOR HEALTH CHECK")
+    print("=" * 60)
+    print()
+
+    print(f"Python: {health.python_version.split()[0]}")
+    print(f"Version: {get_validator_version()}")
+    print()
+
+    print("Required Validators:")
+    for name, validator in sorted(health.validators.items()):
+        status = "[OK]" if validator.healthy else "[MISSING]"
+        print(f"  {status} {name}")
+        if validator.error:
+            print(f"         Error: {validator.error}")
+    print()
+
+    print("Optional Tools:")
+    for tool, available in sorted(health.optional_tools.items()):
+        status = "[OK]" if available else "[NOT INSTALLED]"
+        print(f"  {status} {tool}")
+    print()
+
+    overall = "HEALTHY" if health.all_healthy else "DEGRADED"
+    print(f"Overall Status: {overall}")
+    print("=" * 60)
+
+
+def main() -> int:
+    """Run health check and print report."""
+    health = get_system_health()
+    print_health_report(health)
+    return 0 if health.all_healthy else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/validators/magic_value_checks.py

@@ -0,0 +1,81 @@
+"""Magic value detection validator.
+
+Implements check 7: No hardcoded magic values.
+Use named constants instead of magic numbers.
+
+Note: Only checks for magic numbers. Magic string detection is not implemented.
+"""
+
+import ast
+import sys
+from pathlib import Path
+from typing import List, Set
+
+from validator_base import Violation
+
+
+ALLOWED_NUMBERS: Set[int] = frozenset({-1, 0, 1, 2, 100})
+
+
+def check_magic_values(tree: ast.AST, filename: str) -> List[Violation]:
+    violations: List[Violation] = []
+
+    constant_names: Set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id.isupper():
+                    constant_names.add(target.id)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, int) and node.value not in ALLOWED_NUMBERS:
+                if not _is_in_constant_definition(node, tree):
+                    violations.append(
+                        Violation(
+                            filename,
+                            node.lineno,
+                            f"Magic number {node.value} - use named constant",
+                        )
+                    )
+
+    return violations
+
+
+def _is_in_constant_definition(node: ast.Constant, tree: ast.AST) -> bool:
+    for parent in ast.walk(tree):
+        if isinstance(parent, ast.Assign):
+            for target in parent.targets:
+                if isinstance(target, ast.Name) and target.id.isupper():
+                    if parent.value is node:
+                        return True
+    return False
+
+
+def validate_file(file_path: Path) -> List[Violation]:
+    filename = str(file_path)
+    try:
+        source = file_path.read_text(encoding="utf-8")
+        tree = ast.parse(source)
+    except Exception as error:
+        return [Violation(filename, 0, f"Error: {error}")]
+
+    return check_magic_values(tree, filename)
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        return 1
+
+    all_violations: List[Violation] = []
+    for file_arg in sys.argv[1:]:
+        all_violations.extend(validate_file(Path(file_arg)))
+
+    for violation in all_violations:
+        print(violation)
+
+    return 1 if all_violations else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/validators/mypy_integration.py

@@ -0,0 +1,52 @@
+"""Mypy integration for static type checking."""
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class MypyResult:
+    passed: bool
+    output: str
+    error_count: int
+
+
+def check_mypy_available() -> bool:
+    """Check if mypy is installed."""
+    try:
+        result = subprocess.run(
+            ["mypy", "--version"],
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        return False
+
+
+def run_mypy_check(files: list[Path]) -> MypyResult:
+    """Run mypy on files."""
+    if not files:
+        return MypyResult(passed=True, output="No files to check", error_count=0)
+
+    if not check_mypy_available():
+        return MypyResult(passed=True, output="Mypy not installed - skipping", error_count=0)
+
+    py_files = [str(f) for f in files if f.suffix == ".py"]
+    if not py_files:
+        return MypyResult(passed=True, output="No Python files", error_count=0)
+
+    result = subprocess.run(
+        ["mypy", "--ignore-missing-imports", "--no-error-summary"] + py_files,
+        capture_output=True,
+        text=True,
+    )
+
+    error_count = result.stdout.count(": error:")
+
+    return MypyResult(
+        passed=result.returncode == 0,
+        output=result.stdout or result.stderr or "No type errors",
+        error_count=error_count,
+    )