anvil-dev-framework 0.1.6

package/global/lib/quality_service.py

@@ -0,0 +1,470 @@
+#!/usr/bin/env python3
+"""
+quality_service.py - Quality gate data aggregation for HUD (ANV-103/104)
+
+Runs local quality checks (tests, lint, types) and aggregates results
+for display in the Anvil HUD Quality Gates panel.
+
+Usage:
+    from quality_service import QualityService
+
+    service = QualityService("/path/to/project")
+    results = service.run_checks()
+    print(results["tests"]["passed"], results["tests"]["failed"])
+"""
+
+import json
+import subprocess
+import time
+from pathlib import Path
+from typing import Dict, Optional, TypedDict
+
+
+class CheckResult(TypedDict, total=False):
+    """Result of a single quality check."""
+    status: str          # "passed", "failed", "running", "skipped"
+    passed: int          # Number passed
+    failed: int          # Number failed
+    warnings: int        # Number of warnings
+    errors: int          # Number of errors
+    duration_ms: int     # How long the check took
+    message: str         # Human-readable message
+    last_run: float      # Timestamp of last run
+
+
+class QualityGateResult(TypedDict, total=False):
+    """Aggregated quality gate results for a project."""
+    project_path: str
+    branch: str
+    tests: CheckResult
+    lint: CheckResult
+    types: CheckResult
+    ready_to_merge: bool     # All gates passed
+    blocking_issues: int     # Count of blocking problems
+    last_check: float        # Timestamp of last full check
+
+
+# Cache TTL in seconds
+CACHE_TTL = 30.0
+
+
+class QualityService:
+    """Service for running and caching quality checks (ANV-103/104)."""
+
+    def __init__(self, project_path: Optional[str] = None):
+        """Initialize the service.
+
+        Args:
+            project_path: Path to project root. Defaults to cwd.
+        """
+        self.project_path = Path(project_path) if project_path else Path.cwd()
+        self._cache: Dict[str, QualityGateResult] = {}
+        self._last_check: Dict[str, float] = {}
+
+    def get_results(self, force_refresh: bool = False) -> QualityGateResult:
+        """Get quality gate results, using cache if fresh.
+
+        Args:
+            force_refresh: Force running checks even if cache is fresh
+
+        Returns:
+            QualityGateResult with all check statuses
+        """
+        cache_key = str(self.project_path)
+        now = time.time()
+
+        # Check cache
+        if not force_refresh and cache_key in self._cache:
+            last = self._last_check.get(cache_key, 0)
+            if now - last < CACHE_TTL:
+                return self._cache[cache_key]
+
+        # Run fresh checks
+        result = self.run_checks()
+        self._cache[cache_key] = result
+        self._last_check[cache_key] = now
+
+        return result
+
+    def run_checks(self) -> QualityGateResult:
+        """Run all quality checks and return aggregated results."""
+        branch = self._get_branch()
+
+        # Run checks in sequence (could be parallelized for speed)
+        tests = self._run_tests()
+        lint = self._run_lint()
+        types = self._run_typecheck()
+
+        # Calculate blocking issues and merge readiness
+        blocking = 0
+        if tests.get("failed", 0) > 0:
+            blocking += tests["failed"]
+        if lint.get("errors", 0) > 0:
+            blocking += lint["errors"]
+        if types.get("errors", 0) > 0:
+            blocking += types["errors"]
+
+        ready = (
+            tests.get("status") == "passed" and
+            lint.get("status") == "passed" and
+            types.get("status") == "passed"
+        )
+
+        return {
+            "project_path": str(self.project_path),
+            "branch": branch,
+            "tests": tests,
+            "lint": lint,
+            "types": types,
+            "ready_to_merge": ready,
+            "blocking_issues": blocking,
+            "last_check": time.time(),
+        }
+
+    def _get_branch(self) -> str:
+        """Get current git branch name."""
+        try:
+            result = subprocess.run(
+                ["git", "branch", "--show-current"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            return result.stdout.strip() or "unknown"
+        except Exception:
+            return "unknown"
+
+    def _run_tests(self) -> CheckResult:
+        """Run test suite and parse results."""
+        start = time.time()
+
+        # Check which test command is available
+        package_json = self.project_path / "package.json"
+        if package_json.exists():
+            try:
+                pkg = json.loads(package_json.read_text())
+                scripts = pkg.get("scripts", {})
+
+                # Try npm test first
+                if "test" in scripts:
+                    return self._run_npm_test(start)
+            except Exception:
+                pass
+
+        # No tests configured
+        return {
+            "status": "skipped",
+            "passed": 0,
+            "failed": 0,
+            "warnings": 0,
+            "errors": 0,
+            "duration_ms": int((time.time() - start) * 1000),
+            "message": "No test runner configured",
+            "last_run": time.time(),
+        }
+
+    def _run_npm_test(self, start: float) -> CheckResult:
+        """Run npm test and parse output."""
+        try:
+            result = subprocess.run(
+                ["npm", "test", "--", "--passWithNoTests"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=120,  # 2 minute timeout
+            )
+
+            duration = int((time.time() - start) * 1000)
+            output = result.stdout + result.stderr
+
+            # Parse test results from output
+            passed = 0
+            failed = 0
+
+            # Look for common test output patterns
+            import re
+
+            # Jest/Vitest pattern: "Tests: X passed, Y failed"
+            match = re.search(r"Tests?:\s*(\d+)\s*passed", output)
+            if match:
+                passed = int(match.group(1))
+
+            match = re.search(r"Tests?:\s*\d+\s*passed,\s*(\d+)\s*failed", output)
+            if match:
+                failed = int(match.group(1))
+            elif re.search(r"(\d+)\s*failed", output):
+                match = re.search(r"(\d+)\s*failed", output)
+                if match:
+                    failed = int(match.group(1))
+
+            # Alternative patterns
+            if passed == 0:
+                match = re.search(r"(\d+)\s*passing", output)
+                if match:
+                    passed = int(match.group(1))
+
+            if failed == 0:
+                match = re.search(r"(\d+)\s*failing", output)
+                if match:
+                    failed = int(match.group(1))
+
+            status = "passed" if result.returncode == 0 else "failed"
+
+            return {
+                "status": status,
+                "passed": passed,
+                "failed": failed,
+                "warnings": 0,
+                "errors": failed,
+                "duration_ms": duration,
+                "message": f"{passed} passed" + (f", {failed} failed" if failed else ""),
+                "last_run": time.time(),
+            }
+
+        except subprocess.TimeoutExpired:
+            return {
+                "status": "failed",
+                "passed": 0,
+                "failed": 0,
+                "warnings": 0,
+                "errors": 1,
+                "duration_ms": 120000,
+                "message": "Tests timed out",
+                "last_run": time.time(),
+            }
+        except Exception as e:
+            return {
+                "status": "failed",
+                "passed": 0,
+                "failed": 0,
+                "warnings": 0,
+                "errors": 1,
+                "duration_ms": int((time.time() - start) * 1000),
+                "message": str(e)[:50],
+                "last_run": time.time(),
+            }
+
+    def _run_lint(self) -> CheckResult:
+        """Run linter and parse results."""
+        start = time.time()
+
+        # Check for eslint config
+        has_eslint = any([
+            (self.project_path / f).exists()
+            for f in [".eslintrc", ".eslintrc.js", ".eslintrc.json", ".eslintrc.cjs", "eslint.config.js", "eslint.config.mjs"]
+        ])
+
+        if not has_eslint:
+            # Check package.json for lint script
+            package_json = self.project_path / "package.json"
+            if package_json.exists():
+                try:
+                    pkg = json.loads(package_json.read_text())
+                    if "lint" not in pkg.get("scripts", {}):
+                        return {
+                            "status": "skipped",
+                            "passed": 0,
+                            "failed": 0,
+                            "warnings": 0,
+                            "errors": 0,
+                            "duration_ms": int((time.time() - start) * 1000),
+                            "message": "No linter configured",
+                            "last_run": time.time(),
+                        }
+                except Exception:
+                    pass
+
+        try:
+            result = subprocess.run(
+                ["npm", "run", "lint", "--", "--format", "json"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+
+            duration = int((time.time() - start) * 1000)
+
+            errors = 0
+            warnings = 0
+
+            # Try to parse JSON output
+            try:
+                # ESLint JSON output
+                lint_data = json.loads(result.stdout)
+                if isinstance(lint_data, list):
+                    for file_result in lint_data:
+                        errors += file_result.get("errorCount", 0)
+                        warnings += file_result.get("warningCount", 0)
+            except json.JSONDecodeError:
+                # Fall back to parsing text output
+                import re
+
+                # ESLint text pattern: "X errors and Y warnings"
+                match = re.search(r"(\d+)\s*error", result.stdout + result.stderr)
+                if match:
+                    errors = int(match.group(1))
+
+                match = re.search(r"(\d+)\s*warning", result.stdout + result.stderr)
+                if match:
+                    warnings = int(match.group(1))
+
+            status = "passed" if errors == 0 else "failed"
+
+            return {
+                "status": status,
+                "passed": 0,
+                "failed": 0,
+                "warnings": warnings,
+                "errors": errors,
+                "duration_ms": duration,
+                "message": f"{errors} errors, {warnings} warnings",
+                "last_run": time.time(),
+            }
+
+        except subprocess.TimeoutExpired:
+            return {
+                "status": "failed",
+                "passed": 0,
+                "failed": 0,
+                "warnings": 0,
+                "errors": 1,
+                "duration_ms": 60000,
+                "message": "Lint timed out",
+                "last_run": time.time(),
+            }
+        except Exception:
+            return {
+                "status": "skipped",
+                "passed": 0,
+                "failed": 0,
+                "warnings": 0,
+                "errors": 0,
+                "duration_ms": int((time.time() - start) * 1000),
+                "message": "Lint not available",
+                "last_run": time.time(),
+            }
+
+    def _run_typecheck(self) -> CheckResult:
+        """Run TypeScript type check."""
+        start = time.time()
+
+        # Check for tsconfig
+        tsconfig = self.project_path / "tsconfig.json"
+        if not tsconfig.exists():
+            return {
+                "status": "skipped",
+                "passed": 0,
+                "failed": 0,
+                "warnings": 0,
+                "errors": 0,
+                "duration_ms": int((time.time() - start) * 1000),
+                "message": "TypeScript not configured",
+                "last_run": time.time(),
+            }
+
+        try:
+            # Try npm run typecheck first, then fall back to npx tsc
+            result = subprocess.run(
+                ["npm", "run", "typecheck", "--if-present"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+
+            # Only fall back to npx tsc if typecheck script is missing
+            # (don't fallback on non-zero exit - that means typecheck ran but found errors)
+            if "missing script" in result.stderr.lower():
+                result = subprocess.run(
+                    ["npx", "tsc", "--noEmit"],
+                    cwd=self.project_path,
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+
+            duration = int((time.time() - start) * 1000)
+            output = result.stdout + result.stderr
+
+            # Count errors in output
+            import re
+            errors = len(re.findall(r"error TS\d+:", output))
+
+            # If no pattern matches but exit code is non-zero, count as 1 error
+            if errors == 0 and result.returncode != 0:
+                errors = 1
+
+            status = "passed" if result.returncode == 0 else "failed"
+
+            return {
+                "status": status,
+                "passed": 0,
+                "failed": 0,
+                "warnings": 0,
+                "errors": errors,
+                "duration_ms": duration,
+                "message": f"{errors} errors" if errors else "No errors",
+                "last_run": time.time(),
+            }
+
+        except subprocess.TimeoutExpired:
+            return {
+                "status": "failed",
+                "passed": 0,
+                "failed": 0,
+                "warnings": 0,
+                "errors": 1,
+                "duration_ms": 60000,
+                "message": "Type check timed out",
+                "last_run": time.time(),
+            }
+        except Exception:
+            return {
+                "status": "skipped",
+                "passed": 0,
+                "failed": 0,
+                "warnings": 0,
+                "errors": 0,
+                "duration_ms": int((time.time() - start) * 1000),
+                "message": "Type check not available",
+                "last_run": time.time(),
+            }
+
+    def clear_cache(self) -> None:
+        """Clear cached results."""
+        self._cache.clear()
+        self._last_check.clear()
+
+
+# Singleton services keyed by project path
+_services: Dict[str, QualityService] = {}
+
+
+def get_quality_service(project_path: Optional[str] = None) -> QualityService:
+    """Get or create a quality service for a project path."""
+    path = str(Path(project_path) if project_path else Path.cwd())
+    if path not in _services:
+        _services[path] = QualityService(project_path)
+    return _services[path]
+
+
+if __name__ == "__main__":
+    # Simple test
+    import sys
+
+    project = sys.argv[1] if len(sys.argv) > 1 else "."
+    service = QualityService(project)
+    results = service.run_checks()
+
+    print(f"Project: {results['project_path']}")
+    print(f"Branch: {results['branch']}")
+    print(f"\nTests: {results['tests']['status']}")
+    print(f"  {results['tests']['message']}")
+    print(f"\nLint: {results['lint']['status']}")
+    print(f"  {results['lint']['message']}")
+    print(f"\nTypes: {results['types']['status']}")
+    print(f"  {results['types']['message']}")
+    print(f"\nReady to merge: {results['ready_to_merge']}")
+    print(f"Blocking issues: {results['blocking_issues']}")