vibe-coding-qa 0.5.0__py3-none-any.whl

dashboard/__init__.py

@@ -0,0 +1,10 @@
+"""Vibe Coding QA dashboard (backend API + web UI).
+
+The dashboard is an optional layer on top of the ``vibe_coding_qa`` engine: the
+engine stays the single source of truth for scanning, scoring and the release
+gate, and every dashboard feature works without AI.
+"""
+
+from vibe_coding_qa import __version__
+
+__all__ = ["__version__"]

dashboard/backend/__init__.py

@@ -0,0 +1,11 @@
+"""Vibe Coding QA dashboard backend (FastAPI + SQLite).
+
+This package wraps the existing :mod:`vibe_coding_qa` engine behind a typed HTTP
+API. It never re-implements scanning logic: the engine remains the single source
+of truth for findings, scoring and the release gate.
+"""
+
+__all__ = ["__version__"]
+
+# Kept in sync with vibe_coding_qa.cli and pyproject/CHANGELOG.
+__version__ = "0.5.0"

dashboard/backend/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point: ``python -m dashboard.backend``."""
+
+from .main import main
+
+if __name__ == "__main__":
+    main()

dashboard/backend/ai/__init__.py

@@ -0,0 +1,6 @@
+"""Optional AI features. The engine and the release gate never depend on these."""
+
+from .provider import AIConfig, AIError, ChatProvider
+from .service import AIService
+
+__all__ = ["AIConfig", "AIError", "ChatProvider", "AIService"]

dashboard/backend/ai/provider.py

@@ -0,0 +1,102 @@
+"""OpenAI-compatible chat provider used by the AI features.
+
+The provider is deliberately small and stdlib-only (``urllib``) so the optional
+AI features add no runtime dependency to the core engine. It is provider-neutral:
+any endpoint that speaks the OpenAI chat-completions shape works (OpenRouter,
+Groq, Ollama, vLLM, OpenAI, ...).
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+
+from vibe_coding_qa.scanners import redact_secrets
+
+
+class AIError(RuntimeError):
+    """Raised when an AI call cannot be completed. Message is client-safe."""
+
+
+@dataclass(frozen=True)
+class AIConfig:
+    provider: str
+    api_key: str
+    base_url: str
+    model: str
+    timeout: int
+    max_output_tokens: int
+    share_source_context: bool
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.api_key) and self.provider.lower() not in ("", "none", "false", "0")
+
+
+class ChatProvider:
+    """Minimal OpenAI-compatible chat client."""
+
+    MAX_RESPONSE_BYTES = 1_000_000
+    MAX_OUTPUT_TOKENS = 16_000
+
+    def __init__(self, config: AIConfig):
+        self.config = config
+
+    def complete(self, messages: list[dict], *, max_tokens: int | None = None, temperature: float = 0.2) -> str:
+        if not self.config.enabled:
+            raise AIError("No AI provider is configured.")
+        payload = {
+            "model": self.config.model,
+            "messages": [
+                {"role": message["role"], "content": redact_secrets(str(message["content"]))}
+                for message in messages
+            ],
+            "temperature": temperature,
+            "max_tokens": min(
+                max_tokens or self.config.max_output_tokens,
+                self.MAX_OUTPUT_TOKENS,
+            ),
+        }
+        request = urllib.request.Request(
+            f"{self.config.base_url.rstrip('/')}/chat/completions",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={
+                "Authorization": f"Bearer {self.config.api_key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.config.timeout) as response:
+                raw = response.read(self.MAX_RESPONSE_BYTES + 1)
+                if len(raw) > self.MAX_RESPONSE_BYTES:
+                    raise AIError("The AI provider response exceeded the size limit.")
+                data = json.loads(raw.decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            raise AIError(f"The AI provider rejected the request (HTTP {exc.code}).") from exc
+        except urllib.error.URLError as exc:
+            raise AIError(f"The AI provider could not be reached ({type(exc.reason).__name__}).") from exc
+        except AIError:
+            raise
+        except (TimeoutError, OSError) as exc:
+            raise AIError(f"The AI request failed ({type(exc).__name__}).") from exc
+        except json.JSONDecodeError as exc:
+            raise AIError("The AI provider returned an unreadable response.") from exc
+
+        try:
+            choices = data.get("choices") or []
+            content = choices[0]["message"]["content"]
+        except (IndexError, KeyError, TypeError) as exc:
+            raise AIError("The AI provider returned no message content.") from exc
+        return str(content or "").strip()
+
+    def check(self) -> str:
+        """Run a one-token round trip to confirm the configuration works."""
+        reply = self.complete(
+            [{"role": "user", "content": "Reply with the single word: ready"}],
+            max_tokens=8,
+            temperature=0.0,
+        )
+        return reply[:80]