patchi 0.7.5__py3-none-any.whl

patchi/web/routes/self_improvement.py

@@ -0,0 +1,110 @@
+"""Self-Improvement dashboard — agent profiles, learning, threat model."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.templating import Jinja2Templates
+
+_log = logging.getLogger("patchi.web.routes.self_improvement")
+
+
+router = APIRouter()
+templates = Jinja2Templates(directory=str(Path(__file__).parent.parent / "templates"))
+
+
+def _load_json(root: Path, rel: str) -> dict:
+    p = root / rel
+    if p.is_file():
+        try:
+            return json.loads(p.read_text(encoding="utf-8"))
+        except Exception as _exc:
+            _log.warning('_load_json failed: %s', _exc)
+    return {}
+
+
+@router.get("/self-improvement", response_class=HTMLResponse)
+async def self_improvement(request: Request):
+    root = request.app.state.root
+
+    # Agent profiles
+    try:
+        from patchi.core.ai.agent_profiler import get_all_profiles, get_profile_summary
+
+        profile_summary = get_profile_summary(root)
+        all_profiles = get_all_profiles(root)
+        profiles_data = {k: v.to_dict() for k, v in all_profiles.items()}
+    except Exception:
+        profile_summary = {"agents": 0, "total_runs": 0, "total_cost": 0}
+        profiles_data = {}
+
+    # Learning summary
+    try:
+        from patchi.core.security.attack_feedback import get_learning_summary
+
+        learning = get_learning_summary(root)
+    except Exception:
+        learning = {"acceptances": {}, "rejections": {}, "agent_trust": {}, "skip_types": []}
+
+    # Threat model
+    threat_model = _load_json(root, ".patchi/threat_model.json")
+
+    # Fuzz corpus stats
+    try:
+        from patchi.core.fuzz.corpus import FuzzCorpus
+
+        corpus = FuzzCorpus(root)
+        corpus_stats = corpus.stats()
+    except Exception:
+        corpus_stats = {"total": 0, "avg_score": 0, "strategies": {}}
+
+    # Ignore learner stats
+    try:
+        from patchi.core.security.ignore_learner import IgnoreLearner
+
+        learner = IgnoreLearner(root)
+        learner.build()
+        ignore_count = len(learner.entries)
+    except Exception:
+        ignore_count = 0
+
+    return templates.TemplateResponse(
+        request,
+        "self_improvement.html",
+        {
+            "request": request,
+            "profile_summary": profile_summary,
+            "profiles": profiles_data,
+            "learning": learning,
+            "threat_model": threat_model,
+            "corpus_stats": corpus_stats,
+            "ignore_count": ignore_count,
+        },
+    )
+
+
+@router.get("/api/self-improvement")
+async def api_self_improvement(request: Request):
+    root = request.app.state.root
+    try:
+        from patchi.core.ai.agent_profiler import get_all_profiles, get_profile_summary
+        from patchi.core.security.attack_feedback import get_learning_summary
+
+        profile_summary = get_profile_summary(root)
+        all_profiles = get_all_profiles(root)
+        learning = get_learning_summary(root)
+        threat_model = _load_json(root, ".patchi/threat_model.json")
+        return JSONResponse(
+            {
+                "profiles": profile_summary,
+                "agent_details": {k: v.to_dict() for k, v in all_profiles.items()},
+                "learning": learning,
+                "threat_model": threat_model,
+            }
+        )
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)

patchi/web/routes/settings.py

@@ -0,0 +1,49 @@
+"""Settings route — web UI configuration panel."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+router = APIRouter()
+templates = Jinja2Templates(directory=str(Path(__file__).parent.parent / "templates"))
+
+
+@router.get("/settings", response_class=HTMLResponse)
+async def settings_page(request: Request):
+    root = request.app.state.root
+    from patchi.core import config as cfg
+    from patchi.core import memory as mem
+
+    brain = mem.get_brain(root)
+    config = cfg.load(root)
+
+    safe_keys = {
+        "mode",
+        "theme",
+        "device_tier",
+        "scan_depth",
+        "risk_threshold",
+        "queue_mode",
+        "quiet_hours_start",
+        "quiet_hours_end",
+        "max_parallel_agents",
+        "max_queue_depth",
+        "websocket_timeout",
+    }
+    safe_config = {k: v for k, v in config.items() if k in safe_keys}
+
+    return templates.TemplateResponse(
+        request,
+        "settings.html",
+        {
+            "request": request,
+            "config": safe_config,
+            "framework": brain.get("framework", "Unknown"),
+            "health_score": brain.get("health_score", {}).get("total", 0),
+            "ai_keys": len(config.get("ai", {}).get("keys", [])),
+        },
+    )

patchi/web/routes/tokens.py

@@ -0,0 +1,29 @@
+"""Tokens route — admin token management page."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+router = APIRouter()
+templates = Jinja2Templates(directory=str(Path(__file__).parent.parent / "templates"))
+
+
+@router.get("/tokens", response_class=HTMLResponse)
+async def tokens_page(request: Request):
+    root = request.app.state.root
+    from patchi.core.hosted import tokens as tokens_mod
+
+    token_list = tokens_mod.list_tokens(root)
+
+    return templates.TemplateResponse(
+        request,
+        "tokens.html",
+        {
+            "request": request,
+            "tokens": token_list,
+        },
+    )

patchi/web/spawn.py

@@ -0,0 +1,139 @@
+"""
+Tap-to-spawn handler for the Patchi Brain Map.
+
+Enforces the full spec from patchi_builder_sidenote.md:
+  - Max 5 user-spawned ants simultaneously
+  - 10-second tap cooldown per node
+  - 60-second ant expiry
+  - No spawn if Patchi is idle (returns None — caller shows node inspector)
+  - No spawn on restricted nodes
+  - No spawn if 3+ ants already working on the node
+  - Second tap on same node within 10s is ignored
+
+SpawnManager is instantiated once on server start and shared via FastAPI state.
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import patchi.core.config as config
+
+# Spec constants
+MAX_USER_ANTS = 5
+NODE_COOLDOWN_S = 10
+ANT_EXPIRY_S = 60
+MAX_ANTS_ON_NODE = 3
+
+
+@dataclass
+class SpawnedAnt:
+    ant_id: str
+    node_id: str
+    spawned_at: float = field(default_factory=time.time)
+    done: bool = False
+
+    def is_expired(self) -> bool:
+        return (time.time() - self.spawned_at) > ANT_EXPIRY_S
+
+
+class SpawnManager:
+    """
+    Tracks all user-spawned ants. Called by the WebSocket handler when
+    the client sends an `action.spawn_ant` event.
+    """
+
+    def __init__(self, root: Path) -> None:
+        self._root = root
+        self._ants: dict[str, SpawnedAnt] = {}  # ant_id → SpawnedAnt
+        self._taps: dict[str, float] = {}  # node_id → last tap timestamp
+        self._is_active: bool = False  # set by server when a scan runs
+
+    # ── Lifecycle ─────────────────────────────────────────────────────────────
+
+    def set_active(self, active: bool) -> None:
+        """Called by the scan runner to indicate whether Patchi is running."""
+        self._is_active = active
+
+    def mark_done(self, ant_id: str) -> None:
+        if ant_id in self._ants:
+            self._ants[ant_id].done = True
+
+    # ── Spawn gate ────────────────────────────────────────────────────────────
+
+    def try_spawn(self, node_id: str) -> tuple[str | None, str]:
+        """
+        Attempt to spawn an ant on node_id.
+
+        Returns (ant_id, reason):
+          - (ant_id, "ok")         → spawned successfully
+          - (None, "idle")         → Patchi not running — show inspector instead
+          - (None, "restricted")   → node is restricted
+          - (None, "cooldown")     → same node tapped within 10s
+          - (None, "capacity")     → 5 user-spawned ants already active
+          - (None, "node_busy")    → 3+ ants already on this node
+        """
+        self._expire_ants()
+
+        if not self._is_active:
+            return None, "idle"
+
+        if self._is_restricted(node_id):
+            return None, "restricted"
+
+        if self._on_cooldown(node_id):
+            return None, "cooldown"
+
+        live = self._live_ants()
+        if len(live) >= MAX_USER_ANTS:
+            return None, "capacity"
+
+        ants_on_node = sum(1 for a in live.values() if a.node_id == node_id)
+        if ants_on_node >= MAX_ANTS_ON_NODE:
+            return None, "node_busy"
+
+        ant_id = str(uuid.uuid4())[:8]
+        self._ants[ant_id] = SpawnedAnt(ant_id=ant_id, node_id=node_id)
+        self._taps[node_id] = time.time()
+        return ant_id, "ok"
+
+    def active_count(self) -> int:
+        self._expire_ants()
+        return len(self._live_ants())
+
+    def all_active(self) -> list[dict]:
+        self._expire_ants()
+        return [
+            {"ant_id": a.ant_id, "node_id": a.node_id, "age_s": int(time.time() - a.spawned_at)}
+            for a in self._live_ants().values()
+        ]
+
+    # ── Internal helpers ──────────────────────────────────────────────────────
+
+    def _live_ants(self) -> dict[str, SpawnedAnt]:
+        return {aid: a for aid, a in self._ants.items() if not a.done and not a.is_expired()}
+
+    def _expire_ants(self) -> None:
+        expired = [aid for aid, ant in self._ants.items() if ant.is_expired()]
+        for aid in expired:
+            del self._ants[aid]
+
+    def _on_cooldown(self, node_id: str) -> bool:
+        last = self._taps.get(node_id, 0.0)
+        return (time.time() - last) < NODE_COOLDOWN_S
+
+    def _is_restricted(self, node_id: str) -> bool:
+        """Check config restrictions. node_id is the file path used as Brain Map node key."""
+        try:
+            restrictions = config.get_restrictions(self._root)
+            return any(r["path"] == node_id and r.get("enabled", True) for r in restrictions)
+        except Exception as e:
+            import logging
+
+            logging.getLogger("patchi.web.spawn").warning(
+                "Restriction check failed for %s: %s", node_id, e
+            )
+            return False

patchi/web/ws.py

@@ -0,0 +1,141 @@
+"""
+WebSocket manager for live events.
+
+Broadcasts scan progress, finding alerts, guard events to all connected clients.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class WSManager:
+    """Manages WebSocket connections and broadcasts events."""
+
+    _connections: list = field(default_factory=list)
+    _lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+
+    async def connect(self, ws: Any) -> None:
+        async with self._lock:
+            self._connections.append(ws)
+
+    async def disconnect(self, ws: Any) -> None:
+        async with self._lock:
+            if ws in self._connections:
+                self._connections.remove(ws)
+
+    async def broadcast(self, event: str, data: dict | None = None) -> None:
+        """Send event to all connected clients."""
+        message = json.dumps(
+            {
+                "event": event,
+                "data": data or {},
+                "ts": time.time(),
+            }
+        )
+        async with self._lock:
+            targets = list(self._connections)
+            dead = []
+            for ws in targets:
+                try:
+                    await ws.send_text(message)
+                except Exception:
+                    dead.append(ws)
+            for ws in dead:
+                if ws in self._connections:
+                    self._connections.remove(ws)
+            if dead:
+                import logging
+
+                logging.getLogger("patchi.web.ws").warning(
+                    "Removed %d dead WS connection(s)", len(dead)
+                )
+
+    @property
+    def connection_count(self) -> int:
+        return len(self._connections)
+
+
+# Global instance
+manager = WSManager()
+
+
+# ── Event helpers ─────────────────────────────────────────────────────────────
+
+
+async def evt_scan_started(agent_count: int = 0) -> None:
+    await manager.broadcast("scan.started", {"agent_count": agent_count})
+
+
+async def evt_scan_progress(agent: str, phase: str, current: int, total: int) -> None:
+    await manager.broadcast(
+        "scan.progress",
+        {
+            "agent": agent,
+            "phase": phase,
+            "current": current,
+            "total": total,
+        },
+    )
+
+
+async def evt_scan_finding(finding: dict) -> None:
+    await manager.broadcast("scan.finding", finding)
+
+
+async def evt_scan_complete(total_findings: int, duration_ms: int) -> None:
+    await manager.broadcast(
+        "scan.complete",
+        {
+            "total_findings": total_findings,
+            "duration_ms": duration_ms,
+        },
+    )
+
+
+async def evt_scan_cancelled(total_findings: int) -> None:
+    await manager.broadcast(
+        "scan.cancelled",
+        {"total_findings": total_findings},
+    )
+
+
+async def evt_agent_started(agent_name: str) -> None:
+    await manager.broadcast("agent.started", {"agent": agent_name})
+
+
+async def evt_agent_done(agent_name: str, finding_count: int) -> None:
+    await manager.broadcast(
+        "agent.done",
+        {
+            "agent": agent_name,
+            "finding_count": finding_count,
+        },
+    )
+
+
+async def evt_guard_alert(alert: dict) -> None:
+    await manager.broadcast("guard.alert", alert)
+
+
+async def evt_guard_status(status: dict) -> None:
+    await manager.broadcast("guard.status", status)
+
+
+async def evt_fix_applied(patch_id: str, file_path: str) -> None:
+    await manager.broadcast(
+        "fix.applied",
+        {
+            "patch_id": patch_id,
+            "file_path": file_path,
+        },
+    )
+
+
+async def evt_status_update(status: dict) -> None:
+    await manager.broadcast("status.update", status)