python-checkup 0.0.1__py3-none-any.whl

python_checkup/web/server.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import json
+import secrets
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+from urllib.parse import parse_qs, urlparse
+
+from rich.console import Console
+
+if TYPE_CHECKING:
+    from python_checkup.config import CheckupConfig
+    from python_checkup.models import HealthReport
+    from python_checkup.plan import ScanPlan
+
+err_console = Console(stderr=True)
+
+
+@dataclasses.dataclass
+class RunContext:
+    """Everything needed to re-run analysis from the web UI."""
+
+    project_root: Path
+    config: CheckupConfig
+    files: list[Path]
+    plan: ScanPlan
+    no_cache: bool = False
+    diff_base: str | None = None
+
+
+def _serialize_report(report: HealthReport) -> str:
+    """Convert a HealthReport to JSON, handling Path and Enum values."""
+
+    def _default(obj: object) -> object:
+        from enum import Enum
+        from pathlib import Path as _Path
+
+        if isinstance(obj, _Path):
+            return str(obj)
+        if isinstance(obj, Enum):
+            return obj.value
+        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+    return json.dumps(dataclasses.asdict(report), default=_default)
+
+
+class ReportServer:
+    """Local HTTP server that serves the interactive HTML report."""
+
+    def __init__(
+        self,
+        report: HealthReport | None = None,
+        port: int = 8765,
+        run_context: RunContext | None = None,
+    ):
+        self.report = report
+        self.port = port
+        self.token = secrets.token_urlsafe(32)
+        self.run_context = run_context
+        self._server: HTTPServer | None = None
+        self._lock = threading.Lock()
+
+    @property
+    def url(self) -> str:
+        return f"http://127.0.0.1:{self.port}?token={self.token}"
+
+    def start(self, open_browser: bool = True) -> None:
+        """Start the server and optionally open a browser."""
+        handler = _make_handler(self)
+        self._server = HTTPServer(("127.0.0.1", self.port), handler)
+
+        if open_browser:
+            import webbrowser
+
+            threading.Timer(0.5, webbrowser.open, args=[self.url]).start()
+
+        err_console.print(
+            f"\n[bold green]Report server running at:[/bold green] {self.url}"
+        )
+        err_console.print("[dim]Press Ctrl+C to stop.[/dim]\n")
+
+        try:
+            self._server.serve_forever()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self._server.server_close()
+            err_console.print("\n[dim]Server stopped.[/dim]")
+
+    def rerun_analysis(self, analyzer_names: list[str]) -> HealthReport:
+        """Re-run analysis with the given analyzers and return a new report."""
+        if self.run_context is None:
+            msg = "No run context available for re-run"
+            raise RuntimeError(msg)
+
+        from python_checkup.analyzer_catalog import ANALYZER_CATALOG
+        from python_checkup.models import Category
+        from python_checkup.plan import build_scan_plan
+        from python_checkup.runner import run_analysis
+
+        ctx = self.run_context
+
+        requested = set(analyzer_names)
+        skip_analyzers = set(ANALYZER_CATALOG.keys()) - requested
+
+        # Derive categories from selected analyzers
+        selected_categories: set[Category] = set()
+        for name in requested:
+            if name in ANALYZER_CATALOG:
+                selected_categories.update(ANALYZER_CATALOG[name].categories)
+
+        plan = build_scan_plan(
+            profile=ctx.plan.profile,
+            only_categories=frozenset(selected_categories),
+            skip_categories=frozenset(),
+            include_optional=True,
+            apply_fixes=ctx.plan.apply_fixes,
+            show_fix_suggestions=ctx.plan.show_fix_suggestions,
+            diff_mode=ctx.plan.diff_mode,
+            type_backend=ctx.plan.type_backend,
+        )
+
+        report = asyncio.run(
+            run_analysis(
+                project_root=ctx.project_root,
+                config=ctx.config,
+                files=ctx.files,
+                skip_analyzers=skip_analyzers,
+                quiet=True,
+                no_cache=ctx.no_cache,
+                plan=plan,
+                diff_base=ctx.diff_base,
+            )
+        )
+
+        with self._lock:
+            self.report = report
+
+        return report
+
+
+def _make_handler(server: ReportServer) -> type[BaseHTTPRequestHandler]:
+    """Create a request handler class bound to the server instance."""
+
+    # Build analyzer catalog info for the UI
+    from python_checkup.analyzer_catalog import ANALYZER_CATALOG
+
+    catalog_info = {
+        name: {
+            "name": name,
+            "categories": [c.value for c in info.categories],
+            "optional": info.optional,
+        }
+        for name, info in ANALYZER_CATALOG.items()
+    }
+
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, format: str, *args: object) -> None:  # noqa: A002
+            pass
+
+        def _check_token(self) -> bool:
+            token = self.headers.get("X-Session-Token")
+            if token != server.token:
+                self._json_error(403, "Invalid or missing session token")
+                return False
+            return True
+
+        def _json_response(self, data: dict[str, Any], status: int = 200) -> None:
+            body = json.dumps(data, default=str).encode("utf-8")
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def _json_error(self, status: int, message: str) -> None:
+            self._json_response({"error": message}, status)
+
+        def _read_json_body(self) -> dict[str, Any] | None:
+            length = int(self.headers.get("Content-Length", 0))
+            if length == 0:
+                self._json_error(400, "Empty request body")
+                return None
+            try:
+                result: dict[str, Any] = json.loads(self.rfile.read(length))
+                return result
+            except json.JSONDecodeError:
+                self._json_error(400, "Invalid JSON")
+                return None
+
+        def do_GET(self) -> None:  # noqa: N802
+            parsed = urlparse(self.path)
+
+            if parsed.path in ("/", ""):
+                query = parse_qs(parsed.query)
+                url_token = query.get("token", [None])[0]
+                if url_token != server.token:
+                    self.send_response(403)
+                    self.send_header("Content-Type", "text/plain")
+                    self.end_headers()
+                    self.wfile.write(b"Invalid session token")
+                    return
+
+                from python_checkup.web.template import render_report_html
+
+                report_json = (
+                    _serialize_report(server.report)
+                    if server.report is not None
+                    else "null"
+                )
+                can_rerun = server.run_context is not None
+                html = render_report_html(
+                    report_json,
+                    server.token,
+                    catalog_json=json.dumps(catalog_info),
+                    can_rerun=can_rerun,
+                )
+                body = html.encode("utf-8")
+                self.send_response(200)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+            else:
+                self.send_response(404)
+                self.send_header("Content-Type", "text/plain")
+                self.end_headers()
+                self.wfile.write(b"Not found")
+
+        def do_POST(self) -> None:  # noqa: N802
+            parsed = urlparse(self.path)
+
+            if not self._check_token():
+                return
+
+            if parsed.path == "/api/rerun":
+                if server.run_context is None:
+                    self._json_error(400, "Re-run not available")
+                    return
+
+                body = self._read_json_body()
+                if body is None:
+                    return
+
+                analyzers = body.get("analyzers", [])
+                if not analyzers or not isinstance(analyzers, list):
+                    self._json_error(400, "Provide a non-empty 'analyzers' list")
+                    return
+
+                known = set(catalog_info.keys())
+                unknown = set(analyzers) - known
+                if unknown:
+                    self._json_error(
+                        400,
+                        f"Unknown analyzer(s): {', '.join(sorted(unknown))}",
+                    )
+                    return
+
+                try:
+                    err_console.print(
+                        f"[bold]Re-running with:[/bold] {', '.join(analyzers)}"
+                    )
+                    report = server.rerun_analysis(analyzers)
+                    report_json = _serialize_report(report)
+                    self._json_response({"report": json.loads(report_json)})
+                except Exception as e:
+                    self._json_error(500, f"Analysis failed: {e}")
+            else:
+                self._json_error(404, "Not found")
+
+    return Handler
+
+
+def serve_report(
+    report: HealthReport | None = None,
+    port: int = 8765,
+    run_context: RunContext | None = None,
+) -> None:
+    """Serve the interactive HTML report and open it in the browser."""
+    server = ReportServer(report, port=port, run_context=run_context)
+    server.start(open_browser=True)