patchi 0.7.5__py3-none-any.whl

patchi/core/testing/visual_regression_agent.py

@@ -0,0 +1,260 @@
+"""
+VisualRegressionAgent — Screenshot comparison testing via Playwright.
+
+Takes screenshots at multiple viewports, waits for full render, and compares
+them against stored baselines:
+
+- Baselines stored in ``.patchi/visual_baselines/{route}/``
+- Current shots saved to ``.patchi/evidence/screenshots/visual_regression/``
+- On change, a **pixel-diff overlay** (red boxes around changed regions) is
+  generated so reviewers can see *what* moved, not just that it did.
+- HTTP status (>=400) and console/page errors are surfaced as findings.
+- Every finding carries the screenshot path so the UI can display evidence.
+
+Requires: playwright, Pillow
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from ..agents.base import (
+    AgentDomain,
+    AgentGroup,
+    AgentInput,
+    AgentResult,
+    BaseAgent,
+    Severity,
+    make_finding,
+    register,
+)
+from ._browser import (
+    discover_routes,
+    find_server,
+    open_page,
+    save_screenshot,
+)
+
+VIEWPORTS = [
+    {"width": 1440, "height": 900, "label": "desktop"},
+    {"width": 768, "height": 1024, "label": "tablet"},
+    {"width": 375, "height": 812, "label": "mobile"},
+]
+
+_log = logging.getLogger("patchi.testing.visual_regression_agent")
+
+
+@register
+class VisualRegressionAgent(BaseAgent):
+    """Screenshot diff testing: baseline comparison, layout shifts, visual regressions."""
+
+    group = AgentGroup.TEST
+    domain = AgentDomain.VISUAL
+    name = "VisualRegressionAgent"
+    description = "Screenshot diff testing: baseline comparison, layout shifts, visual regressions"
+    timeout = 240
+
+    def _run(self, inp: AgentInput, result: AgentResult) -> None:
+        try:
+            from playwright.sync_api import sync_playwright  # noqa: F401
+        except ImportError:
+            self.skip(result, "playwright not installed — pip install playwright && playwright install chromium")
+            return
+
+        base_url = find_server(inp.root, inp.config, inp.extra)
+        if not base_url:
+            self.skip(result, "no running server found — start `p web` (default :1612)")
+            return
+
+        routes = discover_routes(inp.config, inp.extra)
+        if not routes:
+            self.skip(result, "no routes discovered")
+            return
+
+        baseline_root = inp.root / ".patchi" / "visual_baselines"
+        evidence_dir = inp.root / ".patchi" / "evidence" / "screenshots" / "visual_regression"
+        evidence_dir.mkdir(parents=True, exist_ok=True)
+
+        shots = 0
+        regressions = 0
+        new_baselines = 0
+        error_pages = 0
+
+        with sync_playwright() as pw:
+            browser = pw.chromium.launch(headless=True)
+            for route in routes[:15]:
+                for vp in VIEWPORTS:
+                    browser.new_context(viewport={"width": vp["width"], "height": vp["height"]})
+                    page_session = open_page(browser, f"{base_url}{route}")
+                    page = page_session.page
+                    try:
+                        slug = route.strip("/").replace("/", "_") or "root"
+                        shot_name = f"{slug}_{vp['label']}"
+                        shot_path = save_screenshot(page, evidence_dir, shot_name)
+                        if shot_path is None:
+                            continue
+                        rel = str(shot_path.relative_to(inp.root))
+                        shots += 1
+
+                        # Surface server / runtime errors as findings + annotation
+                        if page_session.status and page_session.status >= 400:
+                            error_pages += 1
+                            result.add_finding(
+                                make_finding(
+                                    agent=self.name,
+                                    finding_type="page_error",
+                                    severity=Severity.HIGH,
+                                    file=route,
+                                    message=f"HTTP {page_session.status} on {route} ({vp['label']})",
+                                    extra={"viewport": vp["label"], "status": page_session.status,
+                                           "screenshot": rel},
+                                )
+                            )
+                        for ce in page_session.console_errors[:5]:
+                            result.add_finding(
+                                make_finding(
+                                    agent=self.name,
+                                    finding_type="console_error",
+                                    severity=Severity.MEDIUM,
+                                    file=route,
+                                    message=f"Console error on {route} ({vp['label']}): {ce[:160]}",
+                                    extra={"viewport": vp["label"], "screenshot": rel},
+                                )
+                            )
+
+                        # Baseline compare
+                        base_shot = baseline_root / slug / f"{vp['label']}.png"
+                        if not base_shot.exists():
+                            base_shot.parent.mkdir(parents=True, exist_ok=True)
+                            page.screenshot(path=str(base_shot), full_page=True)
+                            new_baselines += 1
+                            result.add_finding(
+                                make_finding(
+                                    agent=self.name,
+                                    finding_type="new_baseline",
+                                    severity=Severity.INFO,
+                                    file=route,
+                                    message=f"New baseline created: {slug} ({vp['label']})",
+                                    extra={"viewport": vp["label"], "screenshot": rel,
+                                           "baseline": str(base_shot.relative_to(inp.root))},
+                                )
+                            )
+                        else:
+                            diff_path, changed = self._diff(base_shot, shot_path, evidence_dir, slug, vp["label"])
+                            if changed:
+                                regressions += 1
+                                result.add_finding(
+                                    make_finding(
+                                        agent=self.name,
+                                        finding_type="visual_regression",
+                                        severity=Severity.MEDIUM,
+                                        file=route,
+                                        message=f"Visual change on {route} ({vp['label']}): {len(changed)} region(s) changed",
+                                        detail=f"Baseline: {base_shot.name}\nCurrent: {shot_path.name}",
+                                        extra={"viewport": vp["label"], "screenshot": rel,
+                                               "baseline": str(base_shot.relative_to(inp.root)),
+                                               "diff": str(diff_path.relative_to(inp.root)) if diff_path else None,
+                                               "regions": len(changed)},
+                                    )
+                                )
+                                # refresh baseline so next run compares against now-current
+                                page.screenshot(path=str(base_shot), full_page=True)
+                    finally:
+                        page.close()
+            browser.close()
+
+        if regressions == 0 and error_pages == 0 and shots > 0:
+            result.add_finding(
+                make_finding(
+                    agent=self.name,
+                    finding_type="visual_summary",
+                    severity=Severity.INFO,
+                    file="(all pages)",
+                    message=f"Visual regression PASSED: {shots} screenshots, 0 regressions, {new_baselines} new baselines",
+                )
+            )
+        elif shots > 0:
+            result.add_finding(
+                make_finding(
+                    agent=self.name,
+                    finding_type="visual_summary",
+                    severity=Severity.MEDIUM,
+                    file="(all pages)",
+                    message=f"Visual regression: {regressions} changes, {error_pages} error pages across {shots} screenshots",
+                )
+            )
+
+        result.data["suite"] = {
+            "runner": "visual_regression",
+            "screenshots": shots,
+            "regressions": regressions,
+            "new_baselines": new_baselines,
+            "error_pages": error_pages,
+        }
+        result.files_scanned = shots
+
+    # ── pixel diff ──────────────────────────────────────────────────────────
+
+    def _diff(self, base_path: Path, curr_path: Path, out_dir: Path, slug: str, label: str):
+        """Return (diff_image_path, changed_regions) using a downscaled pixel diff.
+
+        Requires Pillow. If Pillow is unavailable, falls back to a file-size /
+        hash comparison and reports diffing as unavailable (no crash).
+        """
+        try:
+            from PIL import Image, ImageDraw
+        except Exception:
+            _log.warning("VisualRegressionAgent: Pillow not installed — pixel diff disabled")
+            return None, []
+
+        try:
+            base = Image.open(base_path).convert("RGB")
+            curr = Image.open(curr_path).convert("RGB")
+        except Exception as e:
+            _log.warning("VisualRegressionAgent._diff open failed: %s", e)
+            return None, []
+
+        # Downscale for speed + stable diffing (the overlay is illustrative).
+        max_w = 900
+        for im in (base, curr):
+            if im.width > max_w:
+                h = int(im.height * max_w / im.width)
+                im.thumbnail((max_w, h))
+
+        if base.size != curr.size:
+            # Layout changed dramatically — treat whole image as changed.
+            out = curr.copy()
+            d = ImageDraw.Draw(out)
+            d.rectangle([0, 0, out.width - 1, out.height - 1], outline=(255, 0, 0), width=3)
+            diff_path = out_dir / f"{slug}_{label}_diff.png"
+            out.save(str(diff_path))
+            return diff_path, [list(out.getbbox())]
+
+        bpx, cpx = base.load(), curr.load()
+        bw, bh = base.size
+        cell = 16
+        changed = []
+        for y in range(0, bh, cell):
+            for x in range(0, bw, cell):
+                diff = 0
+                n = 0
+                for yy in range(y, min(y + cell, bh)):
+                    for xx in range(x, min(x + cell, bw)):
+                        br, bg, bb = bpx[xx, yy]
+                        cr, cg, cb = cpx[xx, yy]
+                        diff += abs(br - cr) + abs(bg - cg) + abs(bb - cb)
+                        n += 1
+                if n and diff / n > 55:  # perceptible change in this cell
+                    changed.append((x, y, min(cell, bw - x), min(cell, bh - y)))
+
+        if not changed:
+            return None, []
+
+        out = curr.copy()
+        d = ImageDraw.Draw(out)
+        for (x, y, w, h) in changed:
+            d.rectangle([x, y, x + w, y + h], outline=(255, 0, 0), width=2)
+        diff_path = out_dir / f"{slug}_{label}_diff.png"
+        out.save(str(diff_path))
+        return diff_path, [list(c) for c in changed]

patchi/web/__init__.py

@@ -0,0 +1 @@
+"""Patchi Web UI — FastAPI + htmx security dashboard."""

patchi/web/api/__init__.py

@@ -0,0 +1 @@
+"""Patchi web API endpoints."""

patchi/web/api/brain_map.py

@@ -0,0 +1,114 @@
+"""Brain Map API — node and edge data for the canvas."""
+
+from __future__ import annotations
+
+import os
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+router = APIRouter(prefix="/api/brain-map")
+
+
+@router.get("/nodes")
+async def get_nodes(request: Request) -> JSONResponse:
+    root = request.app.state.root
+    from collections import Counter
+
+    from patchi.core import memory as mem
+
+    brain = mem.get_brain(root)
+    import_graph = brain.get("import_graph", {})
+    nodes_raw = import_graph.get("nodes", [])
+    health = brain.get("health_score", {})
+    dead_files = set(brain.get("dead_files", []))
+
+    # Compute finding counts per file from scan results
+    scan_results = mem.get_scan_results(root)
+    finding_counts: dict[str, int] = Counter()
+    finding_severities: dict[str, str] = {}
+    for _agent_name, data in scan_results.items():
+        for f in data.get("findings", []):
+            file_path = f.get("file", "")
+            if file_path:
+                finding_counts[file_path] += 1
+                sev = f.get("severity", "info")
+                existing = finding_severities.get(file_path)
+                sev_order = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
+                if existing is None or sev_order.get(sev, 4) < sev_order.get(existing, 4):
+                    finding_severities[file_path] = sev
+
+    # Build node list with metadata
+    nodes = []
+    for _i, node_id in enumerate(nodes_raw):
+        # Determine type (maps to BrainMap node shape/color)
+        if any(x in node_id for x in ["main.py", "app.py", "server.py", "__main__.py"]):
+            node_type = "entry_point"
+        elif any(x in node_id for x in ["base.py", "coordinator.py", "brain.py", "config.py"]):
+            node_type = "component"
+        elif any(x in node_id for x in ["test_", "tests/"]):
+            node_type = "test"
+        elif any(x in node_id for x in [".json", ".yaml", ".yml", ".toml", ".env"]):
+            node_type = "config"
+        else:
+            node_type = "default"
+
+        fcount = finding_counts.get(node_id, 0)
+        fsev = finding_severities.get(node_id, "info")
+
+        # Determine status
+        if node_id in dead_files:
+            status = "dead"
+        elif fcount > 0 and fsev == "critical":
+            status = "critical"
+        elif fcount > 5:
+            status = "warning"
+        elif health.get("total", 0) < 30:
+            status = "critical"
+        elif health.get("total", 0) < 70:
+            status = "warning"
+        else:
+            status = "healthy"
+
+        # Position hint based on type
+        x = 0
+        y = 0
+        if node_type == "entry_point":
+            y = -100  # float to top
+        elif node_type == "dead":
+            y = 100  # sink to bottom
+
+        nodes.append(
+            {
+                "id": node_id,
+                "label": os.path.basename(node_id),
+                "file": node_id,
+                "type": node_type,
+                "status": status,
+                "finding_count": fcount,
+                "severity": fsev,
+                "x": x,
+                "y": y,
+            }
+        )
+
+    return JSONResponse({"nodes": nodes})
+
+
+@router.get("/edges")
+async def get_edges(request: Request) -> JSONResponse:
+    root = request.app.state.root
+    from patchi.core import memory as mem
+
+    brain = mem.get_brain(root)
+    import_graph = brain.get("import_graph", {})
+    edges_raw = import_graph.get("edges", {})
+
+    # Convert {source: [targets]} to [{from, to}] format
+    edges = []
+    for source, targets in edges_raw.items():
+        if isinstance(targets, list):
+            for target in targets:
+                edges.append({"from": source, "to": target, "source": source, "target": target})
+
+    return JSONResponse({"edges": edges})

patchi/web/api/charts.py

@@ -0,0 +1,47 @@
+"""Charts API — data for timeline and trends."""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+logger = logging.getLogger("patchi.web.api.charts")
+
+router = APIRouter(prefix="/api/charts")
+
+
+@router.get("/timeline")
+async def get_timeline(request: Request) -> JSONResponse:
+    root = request.app.state.root
+    db_path = root / ".patchi" / "patchi_history.db"
+
+    history = []
+    if db_path.exists():
+        conn = None
+        try:
+            conn = sqlite3.connect(str(db_path))
+            cursor = conn.execute(
+                "SELECT severity_breakdown, findings_count FROM scan_history ORDER BY rowid DESC LIMIT 20"
+            )
+            for row in cursor.fetchall():
+                breakdown = json.loads(row[0] or "{}")
+                history.append(
+                    {
+                        "total": row[1],
+                        "critical": breakdown.get("critical", 0),
+                        "high": breakdown.get("high", 0),
+                        "medium": breakdown.get("medium", 0),
+                        "low": breakdown.get("low", 0),
+                    }
+                )
+        except Exception as e:
+            logger.warning("Failed to fetch chart history: %s", e)
+        finally:
+            if conn:
+                conn.close()
+
+    return JSONResponse({"history": list(reversed(history))})

patchi/web/api/chat.py

@@ -0,0 +1,224 @@
+"""Chat API — AI chat with smart brain context injection."""
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+_log = logging.getLogger("patchi.web.api.chat")
+
+router = APIRouter(prefix="/api/chat")
+
+BASE_PROMPT = """You are Patchi, a security assistant. You help developers understand and fix security issues.
+
+Answer concisely. If asked about specific findings, explain what the issue is and how to fix it.
+Use markdown for formatting."""
+
+
+def _build_context(brain: dict, message: str) -> str:
+    """Build relevant context from brain data based on the user's question."""
+    m_lower = message.lower()
+    parts = []
+
+    file_count = brain.get("file_count", 0)
+    route_count = brain.get("route_count", 0)
+    framework = brain.get("framework", "Unknown")
+    health = brain.get("health_score", {})
+    health_total = health.get("total", 0) if isinstance(health, dict) else health
+    parts.append(
+        f"Project: {file_count} files, {route_count} routes, framework: {framework}, health: {health_total}/100"
+    )
+
+    if any(
+        w in m_lower
+        for w in ["finding", "issue", "vulnerability", "bug", "critical", "high", "error"]
+    ):
+        issues = brain.get("issues", []) or brain.get("findings", [])
+        if issues and isinstance(issues, list):
+            by_sev: dict[str, int] = {}
+            for f in issues:
+                sev = f.get("severity", "info") if isinstance(f, dict) else "info"
+                by_sev[sev] = by_sev.get(sev, 0) + 1
+            if by_sev:
+                parts.append(
+                    f"Issues ({len(issues)} total): {', '.join(f'{c} {s}' for s, c in sorted(by_sev.items()))}"
+                )
+            top = [
+                f
+                for f in issues
+                if isinstance(f, dict) and f.get("severity") in ("critical", "high")
+            ][:5]
+            for f in top:
+                parts.append(
+                    f"  [{f['severity']}] {f.get('file', '')}:{f.get('line', 0)} — {f.get('message', '')[:80]}"
+                )
+
+    if any(w in m_lower for w in ["route", "endpoint", "api", "path"]):
+        routes = brain.get("routes", [])
+        if routes and isinstance(routes, list):
+            samples = []
+            for r in routes[:15]:
+                if isinstance(r, dict):
+                    samples.append(f"  {r.get('method', '?')} {r.get('path', '?')}")
+                else:
+                    samples.append(f"  {r}")
+            if samples:
+                parts.append(f"Routes ({len(routes)} total):\n" + "\n".join(samples[:15]))
+
+    if any(w in m_lower for w in ["security", "cve", "secret", "injection", "xss", "sqli"]):
+        sec = brain.get("security_report", brain.get("security_str", {}))
+        if isinstance(sec, dict):
+            parts.append(
+                f"Security: {sec.get('critical', 0)}c, {sec.get('high', 0)}h, {sec.get('medium', 0)}m"
+            )
+
+    if any(w in m_lower for w in ["patch", "fix", "change"]):
+        patches = brain.get("patches", [])
+        if patches and isinstance(patches, list):
+            applied = sum(
+                1
+                for p in patches
+                if isinstance(p, dict) and p.get("state") in ("applied", "auto_applied")
+            )
+            pending = sum(1 for p in patches if isinstance(p, dict) and p.get("state") == "pending")
+            parts.append(f"Patches: {applied} applied, {pending} pending")
+
+    if any(w in m_lower for w in ["test", "coverage"]):
+        tests = brain.get("test_results", {})
+        if tests:
+            parts.append(f"Tests: {tests.get('passed', 0)} passed, {tests.get('failed', 0)} failed")
+
+    return "\n".join(parts) if parts else ""
+
+
+def _local_fallback(message: str, brain: dict) -> str:
+    """Rule-based fallback when no AI provider is available."""
+    m = message.lower()
+    file_count = brain.get("file_count", 0)
+    framework = brain.get("framework", "Unknown")
+    health = brain.get("health_score", {})
+    health_total = health.get("total", 0) if isinstance(health, dict) else health
+
+    # Greeting
+    if any(w in m for w in ["hello", "hi", "hey", "greetings"]):
+        return (
+            f"Hi! I'm Patchi. This project has {file_count} files, "
+            f"uses {framework}, and has a health score of {health_total}/100. "
+            f"No AI provider is configured — run `p key add` for full AI chat."
+        )
+
+    # Project overview
+    if any(w in m for w in ["project", "about", "what is", "overview"]):
+        purpose = brain.get("project_purpose", "")
+        parts = [f"This is a {framework} project with {file_count} files."]
+        if purpose:
+            parts.append(f"Purpose: {purpose}")
+        parts.append(f"Health score: {health_total}/100.")
+        routes = brain.get("routes", [])
+        if routes:
+            parts.append(f"{len(routes)} routes detected.")
+        return " ".join(parts)
+
+    # Findings / security
+    if any(w in m for w in ["finding", "issue", "vulnerability", "security", "critical", "bug"]):
+        scans = brain.get("scan_results", {})
+        if not scans:
+            from pathlib import Path
+
+            from patchi.core import memory as mem
+            try:
+                scans = mem.get_scan_results(Path(brain.get("_root", ".")))
+            except Exception:
+                scans = {}
+        total = sum(len(v.get("findings", [])) for v in scans.values()) if scans else 0
+        if total:
+            return (
+                f"Found {total} findings across {len(scans)} scanners. "
+                f"Run `p findings` in the CLI for details, or configure an AI provider "
+                f"with `p key add` for AI-powered analysis."
+            )
+        return "No scan results yet. Run `p scan` first to detect findings."
+
+    # Health
+    if any(w in m for w in ["health", "score", "grade"]):
+        grade = health.get("grade", "?") if isinstance(health, dict) else "?"
+        return (
+            f"Health score: {health_total}/100 (grade {grade}). "
+            f"{file_count} files, {framework} framework. "
+            f"Run `p doctor` for a full health check."
+        )
+
+    # Routes
+    if any(w in m for w in ["route", "endpoint", "api", "path"]):
+        routes = brain.get("routes", [])
+        if routes:
+            samples = [f"  {r.get('method', '?')} {r.get('path', '?')}" for r in routes[:10] if isinstance(r, dict)]
+            return f"{len(routes)} routes detected:\n" + "\n".join(samples)
+        return "No routes detected yet. Run `p scan` to discover routes."
+
+    # Help
+    if any(w in m for w in ["help", "how", "what can"]):
+        return (
+            "I can help with:\n"
+            "• **Findings** — ask about security issues and vulnerabilities\n"
+            "• **Project** — overview of your codebase\n"
+            "• **Health** — project health score and grade\n"
+            "• **Routes** — API endpoints and paths\n"
+            "\nFor AI-powered analysis, run `p key add` to configure an AI provider."
+        )
+
+    return (
+        f"I'm Patchi (local mode — no AI provider configured). "
+        f"This {framework} project has {file_count} files with health score {health_total}/100. "
+        f"Ask about findings, project, health, or routes. "
+        f"Run `p key add` for full AI chat."
+    )
+
+
+@router.post("")
+async def chat_message(request: Request) -> JSONResponse:
+    body = await request.json()
+    message = body.get("message", "")
+
+    if not message:
+        return JSONResponse({"ok": False, "error": "No message"}, status_code=400)
+
+    root = request.app.state.root
+    from patchi.core import config as cfg
+    from patchi.core import memory as mem
+
+    try:
+        config = cfg.load(root)
+    except Exception:
+        config = {}
+
+    brain = mem.get_brain(root)
+
+    context = _build_context(brain, message)
+    system = f"{BASE_PROMPT}\n\n{context}" if context else BASE_PROMPT
+
+    # Skip AI call if no real providers configured — use instant local fallback.
+    # AI Horde is too slow for chat; only use it with a custom key, not the anon fallback.
+    ai_cfg = config.get("ai", {})
+    ai_keys = ai_cfg.get("keys", [])
+    has_provider = (
+        ai_keys
+        or ai_cfg.get("local_model_name")
+    )
+    if has_provider:
+        try:
+            from patchi.core.ai.client import call_ai
+
+            response = call_ai(
+                config, system, message,
+                max_tokens=1000, timeout=25,
+            )
+            if response:
+                return JSONResponse({"ok": True, "response": response})
+        except Exception as e:
+            _log.debug("AI call failed: %s", e)
+
+    # Local fallback — rule-based responses when no AI provider is available
+    fallback = _local_fallback(message, brain)
+    return JSONResponse({"ok": True, "response": fallback})