senselab-cli 0.1.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,4 @@
+"""SenseLab CLI package."""
+
+__version__ = "0.1.0"
+

cli/__main__.py

@@ -0,0 +1,6 @@
+from cli.main import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

cli/api.py

@@ -0,0 +1,205 @@
+import json
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urljoin
+
+
+@dataclass
+class APIError(Exception):
+    message: str
+    status_code: int | None = None
+    suggestion: str | None = None
+
+    def __str__(self) -> str:
+        if self.suggestion:
+            return f"{self.message} {self.suggestion}"
+        return self.message
+
+
+class APIClient:
+    def __init__(self, base_url: str, token: str | None, timeout_seconds: int = 60):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self.timeout_seconds = timeout_seconds
+
+    def _headers(self) -> dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        timeout_seconds: int | None = None,
+    ) -> Any:
+        try:
+            import requests
+        except ImportError as e:
+            raise APIError(
+                "Missing dependency 'requests'. Install project dependencies to use CLI API calls."
+            ) from e
+
+        if not self.token:
+            raise APIError(
+                "Not logged in.",
+                suggestion="Run `sense-cli login` or set SENSELAB_TOKEN.",
+            )
+
+        url = urljoin(f"{self.base_url}/", path.lstrip("/"))
+        try:
+            response = requests.request(
+                method=method,
+                url=url,
+                headers=self._headers(),
+                json=json_body,
+                params=params,
+                timeout=timeout_seconds or self.timeout_seconds,
+            )
+        except requests.Timeout as e:
+            raise APIError(
+                "Request timed out while contacting SenseLab API.",
+                suggestion="Try again or check backend availability.",
+            ) from e
+        except requests.RequestException as e:
+            raise APIError(
+                f"Failed to reach API: {e}",
+                suggestion="Check network connectivity and --base-url.",
+            ) from e
+
+        if response.status_code == 401:
+            raise APIError(
+                "Not logged in.",
+                status_code=401,
+                suggestion="Run `sense-cli login` or set SENSELAB_TOKEN.",
+            )
+
+        if response.status_code >= 400:
+            try:
+                payload = response.json()
+                message = payload.get("message") or json.dumps(payload)
+            except Exception:
+                message = response.text or "Unexpected API error."
+            raise APIError(message, status_code=response.status_code)
+
+        if not response.text:
+            return {}
+        try:
+            return response.json()
+        except Exception:
+            return response.text
+
+    def whoami(self) -> dict[str, Any]:
+        result = self._request("GET", "/api/whoami/")
+        return result if isinstance(result, dict) else {"raw": result}
+
+    def get_projects(self) -> list[dict[str, Any]]:
+        result = self._request("GET", "/api/projects")
+        return result if isinstance(result, list) else []
+
+    def get_specialists(self, project_guid: str) -> list[dict[str, Any]]:
+        result = self._request("GET", f"/api/specialists/{project_guid}")
+        return result if isinstance(result, list) else []
+
+    def get_functions(
+        self, project_guid: str, specialist_guid: str
+    ) -> list[dict[str, Any]]:
+        result = self._request(
+            "GET", f"/api/specialists/{project_guid}/workflows/{specialist_guid}"
+        )
+        return result if isinstance(result, list) else []
+
+    def run_orchestrator_sync(
+        self, project_guid: str, query: str, conversation_guid: str | None = None
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {"query": query}
+        if conversation_guid:
+            payload["conversation_guid"] = conversation_guid
+        return self._request(
+            "POST",
+            f"/api/orchestrator/{project_guid}/run-sync",
+            json_body=payload,
+            timeout_seconds=600,
+        )
+
+    def run_specialist_sync(
+        self,
+        project_guid: str,
+        specialist_guid: str,
+        query: str,
+        conversation_guid: str | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {"query": query, "specialist_guid": specialist_guid}
+        if conversation_guid:
+            payload["conversation_guid"] = conversation_guid
+        return self._request(
+            "POST",
+            f"/api/specialist/{project_guid}/run-sync",
+            json_body=payload,
+            timeout_seconds=600,
+        )
+
+    def execute_function(
+        self, project_guid: str, specialist_guid: str, workflow_id: str
+    ) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/api/specialists/{project_guid}/workflows/{specialist_guid}/{workflow_id}",
+        )
+
+    def get_execution_status(
+        self, project_guid: str, workflow_id: str, execution_guid: str
+    ) -> dict[str, Any]:
+        result = self._request(
+            "GET",
+            f"/api/specialists/{project_guid}/workflows/{workflow_id}/{execution_guid}",
+        )
+        return result if isinstance(result, dict) else {"raw": result}
+
+    def list_connectors(self) -> list[dict[str, Any]]:
+        result = self._request("GET", "/api/connectors/list")
+        return result if isinstance(result, list) else []
+
+    def list_connector_instances(self, project_guid: str) -> list[dict[str, Any]]:
+        result = self._request("GET", f"/api/connectors/{project_guid}")
+        return result if isinstance(result, list) else []
+
+    def create_specialist(
+        self, project_guid: str, payload: dict[str, Any]
+    ) -> dict[str, Any]:
+        return self._request("POST", f"/api/specialists/{project_guid}", json_body=payload)
+
+    def update_specialist(
+        self, project_guid: str, specialist_guid: str, payload: dict[str, Any]
+    ) -> dict[str, Any]:
+        return self._request(
+            "PUT",
+            f"/api/specialists/{project_guid}/{specialist_guid}",
+            json_body=payload,
+        )
+
+    def configure_specialist(
+        self, project_guid: str, specialist_guid: str, payload: dict[str, Any]
+    ) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/api/specialists/{project_guid}/{specialist_guid}/config",
+            json_body=payload,
+        )
+
+    def create_specialist_workflows(
+        self,
+        project_guid: str,
+        specialist_guid: str,
+        workflows: list[dict[str, Any]],
+    ) -> list[dict[str, Any]] | dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/api/specialists/{project_guid}/workflows/{specialist_guid}",
+            json_body={"workflows": workflows},
+        )
+

cli/apply.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+import yaml
+
+from cli.api import APIClient, APIError
+
+
+@dataclass
+class ApplyResult:
+    specialist_guid: str
+    connectors_attached: int
+    workflows_created: int
+    config_applied: bool
+
+
+def _is_uuid(value: str) -> bool:
+    try:
+        UUID(value)
+        return True
+    except Exception:
+        return False
+
+
+def _extract_credential_guid(item: dict[str, Any]) -> str | None:
+    for key in ("tool_cred_guid", "cred_guid", "db_secret", "guid", "id"):
+        value = item.get(key)
+        if value:
+            return str(value)
+    return None
+
+
+def _extract_credential_name(item: dict[str, Any]) -> str | None:
+    for key in ("tool_cred_name", "cred_name", "connection_name", "name"):
+        value = item.get(key)
+        if value:
+            return str(value)
+    return None
+
+
+def _resolve_connector_reference(
+    connector_ref: str, connector_instances: list[dict[str, Any]]
+) -> str:
+    if _is_uuid(connector_ref):
+        return connector_ref
+
+    for item in connector_instances:
+        if _extract_credential_name(item) == connector_ref:
+            cred_guid = _extract_credential_guid(item)
+            if cred_guid:
+                return cred_guid
+
+    raise APIError(
+        f"Connector reference '{connector_ref}' not found in project connector instances."
+    )
+
+
+def _build_specialist_payload(spec: dict[str, Any]) -> dict[str, Any]:
+    required = ("name", "system_prompt", "prompt_template", "role_guid", "llm_guid")
+    missing = [field for field in required if not spec.get(field)]
+    if missing:
+        raise APIError(f"assistant is missing required fields: {', '.join(missing)}")
+
+    payload: dict[str, Any] = {
+        "name": spec["name"],
+        "system_prompt": spec["system_prompt"],
+        "prompt_template": spec["prompt_template"],
+        "role_guid": spec["role_guid"],
+        "llm_guid": spec["llm_guid"],
+    }
+    if spec.get("description"):
+        payload["description"] = spec["description"]
+    if spec.get("is_default") is not None:
+        payload["is_default"] = bool(spec["is_default"])
+    return payload
+
+
+def _build_config_payload(connectors: list[dict[str, Any]]) -> dict[str, Any]:
+    config_payload: dict[str, Any] = {}
+    generic_items: list[dict[str, Any]] = []
+    for item in connectors:
+        connector_type = item.get("type")
+        cred_guid = item["resolved_cred_guid"]
+        config = item.get("config", {})
+
+        if connector_type == "github_repos":
+            config_payload["github_repos"] = {
+                "tool_cred_guid": cred_guid,
+                "repos": config.get("repos", []),
+            }
+        elif connector_type == "gitlab_repos":
+            config_payload["gitlab_repos"] = {
+                "tool_cred_guid": cred_guid,
+                "repos": config.get("repos", []),
+            }
+        elif connector_type == "aws_services":
+            config_payload["aws_services"] = {
+                "tool_cred_guid": cred_guid,
+                "region": config.get("region", ""),
+                "services": config.get("services", []),
+                "context": config.get("context", ""),
+            }
+        elif connector_type == "gcp_services":
+            config_payload["gcp_services"] = {
+                "tool_cred_guid": cred_guid,
+                "region": config.get("region", ""),
+                "services": config.get("services", []),
+                "context": config.get("context", ""),
+            }
+        elif connector_type == "generic":
+            generic_items.append(
+                {
+                    "tool_cred_guid": cred_guid,
+                    "plugin": config.get("plugin", ""),
+                    "context": config.get("context", ""),
+                }
+            )
+    if generic_items:
+        config_payload["generic"] = generic_items
+    return config_payload
+
+
+def _build_workflows_payload(functions: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    workflows: list[dict[str, Any]] = []
+    for function in functions:
+        if not isinstance(function, dict):
+            raise APIError("functions entries must be objects.")
+        if not function.get("workflow_name") or not function.get("definition"):
+            raise APIError(
+                "Each function must include workflow_name and definition fields."
+            )
+        workflows.append(
+            {
+                "workflow_name": function["workflow_name"],
+                "definition": function["definition"],
+                "variables": function.get("variables"),
+                "schema_version": function.get("schema_version", "1.0.0"),
+            }
+        )
+    return workflows
+
+
+def load_apply_file(path: str) -> dict[str, Any]:
+    apply_path = Path(path).expanduser()
+    if not apply_path.exists():
+        raise APIError(f"YAML file not found: {apply_path}")
+
+    with apply_path.open("r", encoding="utf-8") as f:
+        parsed = yaml.safe_load(f)
+    if not isinstance(parsed, dict):
+        raise APIError("YAML root must be an object.")
+    return parsed
+
+
+def apply_assistant_config(
+    api: APIClient,
+    project_guid: str,
+    payload: dict[str, Any],
+    dry_run: bool = False,
+) -> ApplyResult:
+    assistant = payload.get("assistant")
+    if not isinstance(assistant, dict):
+        raise APIError("Missing required 'assistant' section in YAML.")
+
+    connectors = payload.get("connectors", [])
+    if connectors is None:
+        connectors = []
+    if not isinstance(connectors, list):
+        raise APIError("'connectors' must be a list.")
+
+    functions = payload.get("functions", [])
+    if functions is None:
+        functions = []
+    if not isinstance(functions, list):
+        raise APIError("'functions' must be a list.")
+
+    specialist_payload = _build_specialist_payload(assistant)
+    connector_instances = api.list_connector_instances(project_guid)
+
+    resolved_connectors: list[dict[str, Any]] = []
+    for connector in connectors:
+        if not isinstance(connector, dict):
+            raise APIError("Each connector entry must be an object.")
+        connector_ref = connector.get("connector")
+        if not connector_ref:
+            raise APIError("Each connector entry must include 'connector'.")
+        resolved_guid = _resolve_connector_reference(str(connector_ref), connector_instances)
+        resolved_connectors.append({**connector, "resolved_cred_guid": resolved_guid})
+
+    workflows_payload = _build_workflows_payload(functions)
+    config_payload = _build_config_payload(resolved_connectors)
+    tool_cred_guids = [item["resolved_cred_guid"] for item in resolved_connectors]
+
+    if dry_run:
+        return ApplyResult(
+            specialist_guid="dry-run",
+            connectors_attached=len(tool_cred_guids),
+            workflows_created=len(workflows_payload),
+            config_applied=bool(config_payload),
+        )
+
+    create_payload = {**specialist_payload}
+    if tool_cred_guids:
+        create_payload["tool_cred_guids"] = tool_cred_guids
+    specialist_result = api.create_specialist(project_guid, create_payload)
+    specialist_guid = specialist_result.get("specialist_guid")
+    if not specialist_guid:
+        raise APIError("Failed to create specialist: missing specialist_guid in response.")
+
+    if config_payload:
+        api.configure_specialist(project_guid, specialist_guid, config_payload)
+
+    if workflows_payload:
+        api.create_specialist_workflows(project_guid, specialist_guid, workflows_payload)
+
+    return ApplyResult(
+        specialist_guid=str(specialist_guid),
+        connectors_attached=len(tool_cred_guids),
+        workflows_created=len(workflows_payload),
+        config_applied=bool(config_payload),
+    )
+

cli/config.py

@@ -0,0 +1,65 @@
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_API_URL = "https://api.raia.live"
+DEFAULT_CONFIG_PATH = Path.home() / ".sense-cli" / "config.json"
+
+
+@dataclass
+class CLIConfig:
+    base_url: str = DEFAULT_API_URL
+    token: str | None = None
+    default_project_guid: str | None = None
+    email: str | None = None
+    frontend_url: str | None = None
+    telemetry_disabled: bool = False
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any]) -> "CLIConfig":
+        return cls(
+            base_url=raw.get("base_url", DEFAULT_API_URL),
+            token=raw.get("token"),
+            default_project_guid=raw.get("default_project_guid"),
+            email=raw.get("email"),
+            frontend_url=raw.get("frontend_url"),
+            telemetry_disabled=bool(raw.get("telemetry_disabled", False)),
+        )
+
+
+def _ensure_parent(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+def get_config_path() -> Path:
+    custom = os.getenv("SENSELAB_CONFIG_PATH")
+    return Path(custom).expanduser() if custom else DEFAULT_CONFIG_PATH
+
+
+def load_config() -> CLIConfig:
+    path = get_config_path()
+    if not path.exists():
+        return CLIConfig()
+
+    with path.open("r", encoding="utf-8") as f:
+        raw = json.load(f)
+    config = CLIConfig.from_dict(raw)
+
+    env_api = os.getenv("SENSELAB_API_URL")
+    env_token = os.getenv("SENSELAB_TOKEN")
+    if env_api:
+        config.base_url = env_api
+    if env_token:
+        config.token = env_token
+    return config
+
+
+def save_config(config: CLIConfig) -> None:
+    path = get_config_path()
+    _ensure_parent(path)
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(asdict(config), f, indent=2, sort_keys=True)
+