quantikmind-cli 0.1.0__py3-none-any.whl

quantikmind_cli/__init__.py

@@ -0,0 +1,6 @@
+"""Quantik Mind CLI package."""
+
+from importlib import metadata as importlib_metadata
+
+
+__version__ = importlib_metadata.version("quantikmind-cli")

quantikmind_cli/agent/__init__.py

@@ -0,0 +1 @@
+"""Local agent foundations for qmind."""

quantikmind_cli/agent/prometheus.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+import requests
+
+
+class PrometheusError(RuntimeError):
+    """Raised when Prometheus cannot be queried or returns an invalid response."""
+
+
+@dataclass(frozen=True)
+class MetricCheck:
+    name: str
+    found: bool
+    warning: str | None = None
+
+
+SERVICE_METRIC_QUERIES = {
+    "cpu_load": "avg by (service)(service_cpu_load)",
+    "error_rate": "rate(service_errors_total[5m])",
+    "request_rate": "rate(service_requests_total[5m])",
+    "latency_p95": "histogram_quantile(0.95, rate(service_response_time_seconds_bucket[5m]))",
+}
+
+
+class PrometheusClient:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        timeout: float = 10.0,
+        session: requests.Session | None = None,
+    ) -> None:
+        self.base_url = normalize_prometheus_url(base_url)
+        self.timeout = timeout
+        self.session = session or requests.Session()
+
+    def query(self, query: str) -> list[Mapping[str, Any]]:
+        url = f"{self.base_url}/api/v1/query"
+        try:
+            response = self.session.get(url, params={"query": query}, timeout=self.timeout)
+        except requests.RequestException as exc:
+            raise PrometheusError(f"Unable to reach Prometheus at {self.base_url}: {exc}") from exc
+
+        if response.status_code >= 400:
+            raise PrometheusError(f"Prometheus query failed with HTTP {response.status_code}")
+
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise PrometheusError("Prometheus returned a non-JSON response") from exc
+
+        if not isinstance(payload, dict) or payload.get("status") != "success":
+            raise PrometheusError("Prometheus returned an unsuccessful or malformed response")
+
+        data = payload.get("data")
+        if not isinstance(data, dict):
+            raise PrometheusError("Prometheus response is missing data")
+
+        result = data.get("result")
+        if not isinstance(result, list):
+            raise PrometheusError("Prometheus response is missing result data")
+
+        return result
+
+    def check_connectivity(self) -> None:
+        self.query("up")
+
+    def check_metric(self, metric_name: str) -> MetricCheck:
+        try:
+            result = self.query(metric_name)
+        except PrometheusError as exc:
+            return MetricCheck(metric_name, found=False, warning=str(exc))
+        return MetricCheck(metric_name, found=bool(result))
+
+    def collect_service_metrics(self) -> dict[str, dict[str, float]]:
+        metrics: dict[str, dict[str, float]] = {}
+        for payload_key, query in SERVICE_METRIC_QUERIES.items():
+            for sample in self.query(query):
+                service = _sample_service(sample)
+                if not service:
+                    continue
+                value = _sample_value(sample)
+                if value is None:
+                    continue
+                metrics.setdefault(service, {})[payload_key] = value
+        return metrics
+
+
+def normalize_prometheus_url(value: str) -> str:
+    normalized = value.strip().rstrip("/")
+    if not normalized:
+        raise PrometheusError("Prometheus URL cannot be empty")
+    return normalized
+
+
+def _sample_service(sample: Mapping[str, Any]) -> str | None:
+    metric = sample.get("metric")
+    if not isinstance(metric, Mapping):
+        return None
+    service = metric.get("service")
+    if service is None:
+        return None
+    normalized = str(service).strip()
+    return normalized or None
+
+
+def _sample_value(sample: Mapping[str, Any]) -> float | None:
+    value = sample.get("value")
+    if not isinstance(value, list) or len(value) < 2:
+        return None
+    try:
+        return float(value[1])
+    except (TypeError, ValueError):
+        return None

quantikmind_cli/agent/push.py

@@ -0,0 +1 @@
+"""Agent push placeholder."""

quantikmind_cli/agent/service.py

@@ -0,0 +1 @@
+"""Agent service placeholder."""

quantikmind_cli/api.py

@@ -0,0 +1,326 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+import requests
+
+from .config import DEFAULT_BASE_URL, resolve_base_url
+
+
+class ApiError(RuntimeError):
+    """Base API client error."""
+
+
+class AuthenticationError(ApiError):
+    """Raised when credentials are missing or rejected."""
+
+
+class NetworkError(ApiError):
+    """Raised when the backend cannot be reached."""
+
+
+class AgentMetricsEndpointUnavailable(ApiError):
+    """Raised when the agent metrics endpoint is not available on the backend."""
+
+
+class QuantikMindApiClient:
+    def __init__(
+        self,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        api_key: str | None = None,
+        token: str | None = None,
+        auth_mode: str = "auto",
+        timeout: float = 30.0,
+        session: requests.Session | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.token = token
+        self.auth_mode = auth_mode
+        self.timeout = timeout
+        self.session = session or requests.Session()
+
+    @classmethod
+    def from_config(
+        cls,
+        repo_config: Mapping[str, Any] | None,
+        credentials: Mapping[str, Any] | None,
+    ) -> "QuantikMindApiClient":
+        credentials = credentials or {}
+        return cls(
+            base_url=resolve_base_url(repo_config),
+            api_key=credentials.get("api_key"),
+            token=credentials.get("token") or credentials.get("access_token"),
+            auth_mode=str(credentials.get("auth_mode") or "auto"),
+        )
+
+    def auth_headers(self) -> dict[str, str]:
+        credential = self.api_key or self.token
+        if not credential:
+            return {}
+        if self.api_key and (
+            self.auth_mode in {"api_key", "api-key-header"} or _looks_like_quantikmind_api_key(self.api_key)
+        ):
+            return {"X-QM-API-Key": self.api_key}
+        return {"Authorization": f"Bearer {credential}"}
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any | None = None,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> Any:
+        url = f"{self.base_url}/{path.lstrip('/')}"
+        merged_headers = {"Accept": "application/json"}
+        merged_headers.update(self.auth_headers())
+        if headers:
+            merged_headers.update(headers)
+
+        try:
+            response = self.session.request(
+                method=method.upper(),
+                url=url,
+                json=json,
+                params=dict(params or {}),
+                headers=merged_headers,
+                timeout=self.timeout,
+            )
+        except requests.RequestException as exc:
+            raise NetworkError(f"Unable to reach Quantik Mind API: {exc}") from exc
+
+        if response.status_code in {401, 403}:
+            raise AuthenticationError(_error_message(response, "Authentication failed"))
+        if response.status_code >= 400:
+            raise ApiError(_error_message(response, f"API request failed with {response.status_code}"))
+
+        if not response.content:
+            return None
+
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise ApiError("API returned a non-JSON response") from exc
+
+    def list_projects(self) -> list[dict[str, Any]]:
+        payload = self.request("GET", "/api/v1/projects/")
+        if not isinstance(payload, list):
+            raise ApiError("API returned an unexpected projects response")
+        return payload
+
+    def get_auth_identity(self) -> dict[str, Any]:
+        payload = self.request("GET", "/api/v1/auth/me")
+        if not isinstance(payload, dict):
+            raise ApiError("API returned an unexpected auth identity response")
+        return payload
+
+    def get_project_by_name(self, name: str) -> dict[str, Any] | None:
+        normalized_name = name.strip().lower()
+        for project in self.list_projects():
+            if str(project.get("name", "")).strip().lower() == normalized_name:
+                return project
+        return None
+
+    def get_project(self, project_id: str) -> dict[str, Any]:
+        payload = self.request("GET", f"/api/v1/projects/{project_id}")
+        if not isinstance(payload, dict):
+            raise ApiError("API returned an unexpected project response")
+        return payload
+
+    def validate_credentials(self) -> bool:
+        try:
+            self.get_auth_identity()
+        except (AuthenticationError, ApiError):
+            self.list_projects()
+        return True
+
+    def create_project(self, name: str) -> dict[str, Any]:
+        payload = self.request("POST", "/api/v1/projects/", json={"name": name})
+        if not isinstance(payload, dict):
+            raise ApiError("API returned an unexpected project creation response")
+        return payload
+
+    def upload_functional_library(
+        self,
+        project_id: str,
+        tests: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        payload = self.request(
+            "POST",
+            "/api/v1/functional/library/upload-library",
+            json=tests,
+            params={"project_id": project_id},
+        )
+        if not isinstance(payload, dict):
+            raise ApiError("API returned an unexpected library upload response")
+        return payload
+
+    def get_signal_readiness(self, project_id: str) -> dict[str, Any]:
+        payload = self.request(
+            "GET",
+            "/api/v1/functional/signal-readiness",
+            params={"project_id": project_id},
+        )
+        if not isinstance(payload, dict):
+            raise ApiError("API returned an unexpected signal-readiness response")
+        return payload
+
+    def get_subscription(self) -> dict[str, Any]:
+        payload = self.request("GET", "/api/v1/subscription/me")
+        if not isinstance(payload, dict):
+            raise ApiError("API returned an unexpected subscription response")
+        return payload
+
+    def select_functional_tests(
+        self,
+        project_id: str,
+        *,
+        changed_files: list[str] | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"project_id": project_id}
+        if changed_files:
+            params["changed_files"] = changed_files
+        payload = self.request(
+            "GET",
+            "/api/v1/functional/select",
+            params=params,
+        )
+        if not isinstance(payload, dict):
+            raise ApiError("API returned an unexpected functional selection response")
+        return payload
+
+    def record_build_commit(
+        self,
+        *,
+        project_id: str,
+        commit_hash: str,
+        message: str,
+        author: str | None = None,
+        branch: str | None = None,
+        files_changed: list[str] | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "project_id": project_id,
+            "commit_hash": commit_hash,
+            "message": message,
+        }
+        if author:
+            payload["author"] = author
+        if branch:
+            payload["branch"] = branch
+        if files_changed is not None:
+            payload["files_changed"] = files_changed
+
+        response = self.request(
+            "POST",
+            "/api/v1/functional/commits/record",
+            json=payload,
+        )
+        if not isinstance(response, dict):
+            raise ApiError("API returned an unexpected build recording response")
+        return response
+
+    def import_functional_history(
+        self,
+        *,
+        project_id: str,
+        records: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        response = self.request(
+            "POST",
+            "/api/v1/functional/history/import",
+            json={
+                "project_id": project_id,
+                "records": records,
+            },
+        )
+        if not isinstance(response, dict):
+            raise ApiError("API returned an unexpected history import response")
+        return response
+
+    def push_agent_metrics(self, payload: Mapping[str, Any]) -> dict[str, Any]:
+        try:
+            response = self.request("POST", "/api/v1/agent/metrics", json=dict(payload))
+        except ApiError as exc:
+            if "404" in str(exc):
+                raise AgentMetricsEndpointUnavailable(str(exc)) from exc
+            raise
+
+        if response is None:
+            return {}
+        if not isinstance(response, dict):
+            raise ApiError("API returned an unexpected agent metrics response")
+        return response
+
+    def configure_prometheus_observability(self, payload: Mapping[str, Any]) -> dict[str, Any]:
+        response = self.request(
+            "PUT",
+            "/api/v1/observability/prometheus",
+            json=dict(payload),
+        )
+        if not isinstance(response, dict):
+            raise ApiError("API returned an unexpected observability configuration response")
+        return response
+
+    def get_observability_status(self, project_id: str) -> dict[str, Any]:
+        response = self.request(
+            "GET",
+            "/api/v1/observability/status",
+            params={"project_id": project_id},
+        )
+        if not isinstance(response, dict):
+            raise ApiError("API returned an unexpected observability status response")
+        return response
+
+
+def _error_message(response: requests.Response, fallback: str) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        text = response.text.strip()
+        return f"{fallback}: {text}" if text else fallback
+
+    detail = payload.get("detail") if isinstance(payload, dict) else None
+    if isinstance(detail, dict):
+        message = str(detail.get("detail") or detail)
+        errors = detail.get("errors")
+        if isinstance(errors, list) and errors:
+            rendered_errors = []
+            for item in errors:
+                if isinstance(item, dict):
+                    prefix_parts = [
+                        str(item[key])
+                        for key in ("file", "test_id", "index")
+                        if item.get(key) is not None
+                    ]
+                    prefix = ": ".join(prefix_parts)
+                    error_text = str(item.get("error") or item)
+                    rendered_errors.append(f"- {prefix}: {error_text}" if prefix else f"- {error_text}")
+                else:
+                    rendered_errors.append(f"- {item}")
+            message = message + "\n" + "\n".join(rendered_errors)
+        detections = detail.get("detections")
+        if isinstance(detections, list) and detections:
+            rendered_detections = []
+            for item in detections:
+                if not isinstance(item, dict):
+                    continue
+                preset = item.get("preset") or "unknown"
+                detected = ", ".join(item.get("detected_signals") or []) or "none"
+                missing = ", ".join(item.get("missing_signals") or []) or "none"
+                rendered_detections.append(
+                    f"- {preset}: detected={detected}; missing={missing}"
+                )
+            if rendered_detections:
+                message = message + "\n" + "\n".join(rendered_detections)
+        return f"{fallback}: {message}"
+    if detail:
+        return f"{fallback}: {detail}"
+    return fallback
+
+
+def _looks_like_quantikmind_api_key(value: str) -> bool:
+    return value.startswith(("qm_dev_", "qm_live_"))