velune-cli 0.9.0__py3-none-any.whl

velune/providers/discovery/gpu.py

@@ -0,0 +1,117 @@
+"""GPU/VRAM detection."""
+
+import subprocess
+from typing import Any
+
+# Process-wide cache: GPU topology does not change during a run, and the probe
+# (subprocess + driver query) is comparatively expensive. Memoizing also dedupes
+# the historically-double probe (runtime bootstrap + hardware detector).
+_GPU_CACHE: dict[str, Any] | None = None
+
+# Subprocess probes must never block startup if a GPU driver is wedged.
+_PROBE_TIMEOUT = 3.0
+
+
+class GPUDetector:
+    """Detects GPU capabilities and VRAM."""
+
+    def detect(self) -> dict[str, Any]:
+        """Detect GPU information (memoized for the process lifetime)."""
+        global _GPU_CACHE
+        if _GPU_CACHE is not None:
+            return dict(_GPU_CACHE)
+        info = {
+            "has_gpu": False,
+            "gpu_type": None,
+            "vram_total_gb": None,
+            "vram_free_gb": None,
+            "cuda_available": False,
+        }
+
+        # Try NVIDIA -> AMD (ROCm) -> Apple Silicon (Metal), first hit wins.
+        for probe in (self._detect_nvidia, self._detect_amd, self._detect_metal):
+            result = probe()
+            if result:
+                info.update(result)
+                break
+
+        _GPU_CACHE = dict(info)
+        return info
+
+    def _detect_nvidia(self) -> dict[str, Any] | None:
+        """Detect NVIDIA GPU via nvidia-smi."""
+        try:
+            result = subprocess.run(
+                [
+                    "nvidia-smi",
+                    "--query-gpu=name,memory.total,memory.free",
+                    "--format=csv,noheader",
+                ],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=_PROBE_TIMEOUT,
+            )
+
+            lines = result.stdout.strip().split("\n")
+            if not lines:
+                return None
+
+            parts = lines[0].split(",")
+            gpu_name = parts[0].strip()
+            memory_total = parts[1].strip().replace(" MiB", "")
+            memory_free = parts[2].strip().replace(" MiB", "")
+
+            return {
+                "has_gpu": True,
+                "gpu_type": "nvidia",
+                "gpu_name": gpu_name,
+                "vram_total_gb": float(memory_total) / 1024,
+                "vram_free_gb": float(memory_free) / 1024,
+                "cuda_available": True,
+            }
+        except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
+            return None
+
+    def _detect_amd(self) -> dict[str, Any] | None:
+        """Detect AMD GPU via rocm-smi."""
+        try:
+            subprocess.run(
+                ["rocm-smi", "--showmeminfo", "vram"],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=_PROBE_TIMEOUT,
+            )
+
+            # Parse rocm-smi output (simplified)
+            return {
+                "has_gpu": True,
+                "gpu_type": "amd",
+                "cuda_available": False,
+            }
+        except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
+            return None
+
+    def _detect_metal(self) -> dict[str, Any] | None:
+        """Detect Apple Silicon GPU via Metal."""
+        try:
+            import platform
+
+            if platform.machine() != "arm64":
+                return None
+
+            # Apple Silicon has unified memory
+            import psutil
+
+            total_memory = psutil.virtual_memory().total / (1024**3)  # GB
+
+            return {
+                "has_gpu": True,
+                "gpu_type": "apple_silicon",
+                "vram_total_gb": total_memory,
+                "vram_free_gb": total_memory * 0.8,  # Assume 80% available
+                "cuda_available": False,
+            }
+        except Exception:
+            return None

velune/providers/discovery/groq.py

@@ -0,0 +1,21 @@
+"""Groq model discovery — returns GROQ_MODELS when a key is configured."""
+
+from __future__ import annotations
+
+from velune.core.types.model import ModelDescriptor
+from velune.providers import keystore
+
+
+class GroqDiscovery:
+    """Returns the hardcoded Groq model list when a key is configured."""
+
+    provider_id = "groq"
+
+    async def discover(self) -> list[ModelDescriptor]:
+        # Call through the module (not a from-imported name) so the check
+        # always reflects the current keystore state and stays patchable.
+        if not keystore.has_key("groq"):
+            return []
+        from velune.providers.adapters.groq import GROQ_MODELS
+
+        return GROQ_MODELS

velune/providers/discovery/huggingface.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from velune.core.types.model import CapabilityLevel, ModelCapabilityProfile, ModelDescriptor
+
+
+class HuggingFaceDiscovery:
+    """Discovers models from HuggingFace cache."""
+
+    def __init__(self):
+        self.provider_id = "huggingface"
+        self.cache_path = Path.home() / ".cache" / "huggingface" / "hub"
+
+    async def discover(self) -> list[ModelDescriptor]:
+        """Discover models from HuggingFace cache."""
+        models = []
+
+        if not self.cache_path.exists():
+            return models
+
+        # Look for model directories
+        for model_dir in self.cache_path.iterdir():
+            if not model_dir.is_dir():
+                continue
+
+            descriptor = self._parse_model_dir(model_dir)
+            if descriptor:
+                models.append(descriptor)
+
+        return models
+
+    def _parse_model_dir(self, model_dir: Path) -> ModelDescriptor:
+        """Parse model directory into descriptor."""
+        model_id = model_dir.name
+
+        # Basic capability classification
+        capabilities = self._classify_capabilities(model_id)
+
+        return ModelDescriptor(
+            model_id=model_id,
+            provider_id=self.provider_id,
+            display_name=model_id,
+            context_length=4096,
+            capabilities=capabilities,
+            quantization=None,
+            vram_required_gb=None,
+            parameter_count_b=None,
+            speed_tier="medium",
+            cost_per_1k_tokens=None,
+            tags=["local", "huggingface"],
+            metadata={"cache_path": str(model_dir)},
+        )
+
+    def _classify_capabilities(self, model_id: str) -> ModelCapabilityProfile:
+        """Classify capabilities from model ID."""
+        model_lower = model_id.lower()
+
+        profile = ModelCapabilityProfile()
+
+        if any(name in model_lower for name in ["coder", "code"]):
+            profile.coding = CapabilityLevel.INTERMEDIATE
+
+        profile.reasoning = CapabilityLevel.BASIC
+        profile.instruction_following = CapabilityLevel.BASIC
+
+        return profile

velune/providers/discovery/lmstudio.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from velune.core.types.model import CapabilityLevel, ModelCapabilityProfile, ModelDescriptor
+
+logger = logging.getLogger("velune.providers.discovery.lmstudio")
+
+
+class LMStudioDiscovery:
+    """Discovers models from LM Studio."""
+
+    def __init__(self):
+        self.provider_id = "lmstudio"
+        self.base_url = "http://localhost:1234"
+
+    @classmethod
+    async def is_running(cls) -> bool:
+        """Return True if the LM Studio server is reachable."""
+        try:
+            async with httpx.AsyncClient(timeout=2.0) as client:
+                r = await client.head("http://localhost:1234")
+                return r.status_code < 500
+        except Exception:
+            return False
+
+    async def discover(self) -> list[ModelDescriptor]:
+        """Discover models from LM Studio."""
+        models = []
+
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(f"{self.base_url}/v1/models")
+                response.raise_for_status()
+                data = response.json()
+
+                for model in data.get("data", []):
+                    descriptor = self._parse_model(model)
+                    if descriptor:
+                        models.append(descriptor)
+        except Exception as e:
+            logger.debug("LM Studio discovery failed: %s", e)
+
+        return models
+
+    def _parse_model(self, model_data: dict) -> ModelDescriptor:
+        model_id = model_data["id"]
+        capabilities = self._classify_capabilities(model_id)
+
+        return ModelDescriptor(
+            model_id=model_id,
+            provider_id=self.provider_id,
+            display_name=model_id,
+            context_length=4096,
+            capabilities=capabilities,
+            quantization=None,
+            vram_required_gb=None,
+            parameter_count_b=None,
+            speed_tier="medium",
+            cost_per_1k_tokens=None,
+            tags=["local", "lmstudio"],
+            metadata={"raw": model_data},
+        )
+
+    def _classify_capabilities(self, model_id: str) -> ModelCapabilityProfile:
+        model_lower = model_id.lower()
+        profile = ModelCapabilityProfile()
+
+        if any(name in model_lower for name in ["coder", "code"]):
+            profile.coding = CapabilityLevel.INTERMEDIATE
+        else:
+            profile.coding = CapabilityLevel.BASIC
+
+        profile.reasoning = CapabilityLevel.BASIC
+        profile.instruction_following = CapabilityLevel.INTERMEDIATE
+        profile.summarization = CapabilityLevel.BASIC
+
+        return profile

velune/providers/discovery/ollama.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+
+import httpx
+
+from velune.core.types.model import CapabilityLevel, ModelCapabilityProfile, ModelDescriptor
+from velune.providers.discovery.gpu import GPUDetector
+
+logger = logging.getLogger("velune.providers.discovery.ollama")
+
+
+class OllamaDiscovery:
+    """Discovers models from Ollama."""
+
+    def __init__(self):
+        self.provider_id = "ollama"
+        self.base_url = "http://localhost:11434"
+        self.gpu_detector = GPUDetector()
+
+    @classmethod
+    async def is_running(cls) -> bool:
+        """Return True if the Ollama daemon is reachable."""
+        try:
+            async with httpx.AsyncClient(timeout=2.0) as client:
+                r = await client.head("http://localhost:11434")
+                return r.status_code < 500
+        except Exception:
+            return False
+
+    async def _get_model_details(self, model_name: str) -> dict:
+        try:
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                r = await client.post(f"{self.base_url}/api/show", json={"name": model_name})
+                data = r.json()
+                modelfile = data.get("modelfile", "")
+                for line in modelfile.splitlines():
+                    if line.strip().upper().startswith("PARAMETER NUM_CTX"):
+                        try:
+                            return {"num_ctx": int(line.split()[-1])}
+                        except ValueError:
+                            pass
+        except Exception:
+            pass
+        return {}
+
+    async def discover(self) -> list[ModelDescriptor]:
+        """Discover models from Ollama."""
+        models = []
+
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(f"{self.base_url}/api/tags")
+                response.raise_for_status()
+                data = response.json()
+
+                gpu_info = self.gpu_detector.detect()
+
+                tasks = [self._get_model_details(model["name"]) for model in data.get("models", [])]
+                details_list = await asyncio.gather(*tasks, return_exceptions=True)
+
+                for model, details in zip(data.get("models", []), details_list, strict=False):
+                    if isinstance(details, dict) and "num_ctx" in details:
+                        if "details" not in model or not isinstance(model["details"], dict):
+                            model["details"] = {}
+                        model["details"]["num_ctx"] = details["num_ctx"]
+
+                    descriptor = self._parse_model(model, gpu_info)
+                    if descriptor:
+                        models.append(descriptor)
+        except Exception as e:
+            logger.debug("Ollama discovery failed: %s", e)
+
+        return models
+
+    def _parse_model(self, model_data: dict, gpu_info: dict) -> ModelDescriptor:
+        model_id = model_data["name"]
+        details = model_data.get("details", {})
+        quantization = self._extract_quantization(model_id)
+        vram_gb = self._estimate_vram(details, quantization)
+        capabilities = self._classify_capabilities(model_id)
+
+        return ModelDescriptor(
+            model_id=model_id,
+            provider_id=self.provider_id,
+            display_name=model_id,
+            context_length=details.get("num_ctx", 4096),
+            capabilities=capabilities,
+            is_local=True,
+            quantization=quantization,
+            vram_required_gb=vram_gb,
+            parameter_count_b=details.get("parameter_count"),
+            speed_tier="medium",
+            cost_per_1k_tokens=None,
+            tags=["local", "ollama"],
+            metadata={"details": details},
+        )
+
+    def _extract_quantization(self, model_id: str) -> str | None:
+        quant_map = {
+            "q4_k_m": "Q4_K_M",
+            "q4_0": "Q4_0",
+            "q5_k_m": "Q5_K_M",
+            "q5_0": "Q5_0",
+            "q8_0": "Q8_0",
+            "fp16": "FP16",
+            "f16": "F16",
+        }
+        model_lower = model_id.lower()
+        for key, value in quant_map.items():
+            if key in model_lower:
+                return value
+        return None
+
+    def _estimate_vram(self, details: dict, quantization: str | None) -> float | None:
+        param_count = details.get("parameter_count", 0)
+        if not param_count:
+            return None
+        vram_per_param_gb = {
+            None: 2.0,
+            "FP16": 2.0,
+            "F16": 2.0,
+            "Q8_0": 1.0,
+            "Q5_K_M": 0.7,
+            "Q5_0": 0.7,
+            "Q4_K_M": 0.5,
+            "Q4_0": 0.5,
+        }
+        vram_per_param = vram_per_param_gb.get(quantization, 0.5)
+        return (param_count * vram_per_param) / 1e9
+
+    def _classify_capabilities(self, model_id: str) -> ModelCapabilityProfile:
+        model_lower = model_id.lower()
+        profile = ModelCapabilityProfile()
+
+        if any(name in model_lower for name in ["coder", "code", "deepseek-coder", "qwen-coder"]):
+            profile.coding = CapabilityLevel.ADVANCED
+        elif any(name in model_lower for name in ["llama", "mistral", "qwen"]):
+            profile.coding = CapabilityLevel.INTERMEDIATE
+
+        if any(name in model_lower for name in ["r1", "reason", "deepseek-r1"]):
+            profile.reasoning = CapabilityLevel.ADVANCED
+        elif any(name in model_lower for name in ["qwq", "qwen"]):
+            profile.reasoning = CapabilityLevel.INTERMEDIATE
+
+        if profile.reasoning >= CapabilityLevel.INTERMEDIATE:
+            profile.planning = CapabilityLevel.INTERMEDIATE
+
+        if any(name in model_lower for name in ["llama", "mistral"]):
+            profile.summarization = CapabilityLevel.INTERMEDIATE
+
+        if "instruct" in model_lower or "chat" in model_lower:
+            profile.instruction_following = CapabilityLevel.INTERMEDIATE
+
+        if any(name in model_lower for name in ["long", "32k", "128k"]):
+            profile.long_context = CapabilityLevel.INTERMEDIATE
+
+        if profile.instruction_following >= CapabilityLevel.INTERMEDIATE:
+            profile.tool_use = CapabilityLevel.INTERMEDIATE
+
+        return profile

velune/providers/discovery/openai.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import httpx
+
+from velune.core.types.model import CapabilityLevel, ModelCapabilityProfile, ModelDescriptor
+from velune.providers.keystore import get_key
+
+
+class OpenAIDiscovery:
+    """Discovers models from OpenAI."""
+
+    def __init__(self):
+        self.provider_id = "openai"
+        self.api_key = get_key("openai")
+        self.base_url = "https://api.openai.com/v1"
+
+    async def discover(self) -> list[ModelDescriptor]:
+        """Discover models from OpenAI."""
+        if not self.api_key:
+            return []
+
+        models = []
+
+        try:
+            headers = {"Authorization": f"Bearer {self.api_key}"}
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.get(
+                    f"{self.base_url}/models",
+                    headers=headers,
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                for model in data.get("data", []):
+                    if "gpt" in model["id"].lower():
+                        descriptor = self._parse_model(model)
+                        if descriptor:
+                            models.append(descriptor)
+        except Exception:
+            pass
+
+        return models
+
+    def _parse_model(self, model_data: dict) -> ModelDescriptor:
+        """Parse model data into descriptor."""
+        model_id = model_data["id"]
+
+        capabilities = self._classify_capabilities(model_id)
+
+        # Determine context length and cost
+        if "gpt-4" in model_id:
+            context_length = 128000
+            cost_per_1k = 0.03
+        elif "gpt-3.5" in model_id:
+            context_length = 16385
+            cost_per_1k = 0.002
+        else:
+            context_length = 4096
+            cost_per_1k = 0.001
+
+        return ModelDescriptor(
+            model_id=model_id,
+            provider_id=self.provider_id,
+            display_name=model_id,
+            context_length=context_length,
+            capabilities=capabilities,
+            quantization=None,
+            vram_required_gb=None,
+            parameter_count_b=None,
+            speed_tier="fast",
+            cost_per_1k_tokens=cost_per_1k,
+            tags=["cloud", "openai"],
+            metadata={"raw": model_data},
+        )
+
+    def _classify_capabilities(self, model_id: str) -> ModelCapabilityProfile:
+        """Classify capabilities for OpenAI models."""
+        profile = ModelCapabilityProfile()
+
+        if "gpt-4" in model_id:
+            profile.coding = CapabilityLevel.ADVANCED
+            profile.reasoning = CapabilityLevel.EXPERT
+            profile.planning = CapabilityLevel.EXPERT
+            profile.summarization = CapabilityLevel.ADVANCED
+            profile.instruction_following = CapabilityLevel.EXPERT
+            profile.tool_use = CapabilityLevel.EXPERT
+            profile.long_context = CapabilityLevel.ADVANCED
+        elif "gpt-3.5" in model_id:
+            profile.coding = CapabilityLevel.INTERMEDIATE
+            profile.reasoning = CapabilityLevel.INTERMEDIATE
+            profile.planning = CapabilityLevel.INTERMEDIATE
+            profile.summarization = CapabilityLevel.INTERMEDIATE
+            profile.instruction_following = CapabilityLevel.INTERMEDIATE
+            profile.tool_use = CapabilityLevel.INTERMEDIATE
+
+        return profile

velune/providers/discovery/openrouter.py

@@ -0,0 +1,113 @@
+"""OpenRouter model discovery with 1-hour local cache."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+import httpx
+
+from velune.core.types.model import CapabilityLevel, ModelCapabilityProfile, ModelDescriptor
+from velune.providers.keystore import get_key
+
+_CACHE_TTL = 3600.0  # seconds
+
+
+def _cache_path() -> Path:
+    """Resolve the cache file location, preferring the project .velune dir."""
+    project = Path.cwd() / ".velune"
+    if project.exists():
+        return project / "openrouter_models_cache.json"
+    home = Path.home() / ".velune"
+    home.mkdir(parents=True, exist_ok=True)
+    return home / "openrouter_models_cache.json"
+
+
+class OpenRouterDiscovery:
+    """Fetches the full OpenRouter model catalogue with a 1-hour disk cache."""
+
+    provider_id = "openrouter"
+
+    async def discover(self) -> list[ModelDescriptor]:
+        if not get_key("openrouter"):
+            return []
+
+        cached = self._load_cache()
+        if cached is not None:
+            return cached
+
+        models = await self._fetch()
+        self._save_cache(models)
+        return models
+
+    def _load_cache(self) -> list[ModelDescriptor] | None:
+        path = _cache_path()
+        if not path.exists():
+            return None
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            if time.time() - data.get("cached_at", 0) > _CACHE_TTL:
+                return None
+            return [self._raw_to_descriptor(m) for m in data.get("models", [])]
+        except Exception:
+            return None
+
+    def _save_cache(self, models: list[ModelDescriptor]) -> None:
+        path = _cache_path()
+        try:
+            raw = [
+                {
+                    "id": m.model_id,
+                    "name": m.display_name,
+                    "context_length": m.context_length,
+                    "cost_per_1k_tokens": m.cost_per_1k_tokens,
+                }
+                for m in models
+            ]
+            path.write_text(
+                json.dumps({"cached_at": time.time(), "models": raw}, indent=2),
+                encoding="utf-8",
+            )
+        except Exception:
+            pass
+
+    async def _fetch(self) -> list[ModelDescriptor]:
+        api_key = get_key("openrouter")
+        try:
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "HTTP-Referer": "Velune CLI",
+                "X-Title": "Velune CLI",
+            }
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.get(
+                    "https://openrouter.ai/api/v1/models",
+                    headers=headers,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+                return [self._raw_to_descriptor(m) for m in data.get("data", [])]
+        except Exception:
+            return []
+
+    def _raw_to_descriptor(self, raw: dict) -> ModelDescriptor:
+        model_id = raw.get("id", "unknown")
+        context = raw.get("context_length") or 4096
+        pricing = raw.get("pricing", {})
+        cost = float(pricing.get("prompt", 0) or 0) * 1000
+        return ModelDescriptor(
+            model_id=model_id,
+            provider_id="openrouter",
+            display_name=raw.get("name") or model_id,
+            context_length=context,
+            capabilities=ModelCapabilityProfile(
+                coding=CapabilityLevel.INTERMEDIATE,
+                reasoning=CapabilityLevel.INTERMEDIATE,
+                instruction_following=CapabilityLevel.ADVANCED,
+            ),
+            speed_tier="medium",
+            cost_per_1k_tokens=cost if cost > 0 else None,
+            tags=["cloud", "openrouter"],
+            metadata={},
+        )