feat: implement GPU auto-scaling, model presets, and hot-swappable CLI overrides

Author: anujsingh-cse

ghostcoder/backends/__init__.py

@@ -0,0 +1 @@
+# GhostCoder Backends

ghostcoder/backends/gpu_tier.py

@@ -0,0 +1,121 @@
+import subprocess
+import shutil
+from dataclasses import dataclass
+from typing import Dict, Any
+
+@dataclass
+class GPUTier:
+    name: str
+    vram_gb: float
+    tier: str  # "entry" | "mid" | "high" | "workstation" | "datacenter"
+    max_model_size: float  # max parameter size in B (billion)
+
+# Recommended model presets for each tier
+MODEL_PRESETS: Dict[str, Dict[str, str]] = {
+    "entry": {
+        "classifier": "qwen2.5:0.5b",
+        "coder": "qwen2.5-coder:1.5b",
+        "reasoner": "qwen2.5-coder:1.5b",
+        "skeptic": "qwen2.5:0.5b"
+    },
+    "mid": {
+        "classifier": "qwen2.5:0.5b",
+        "coder": "qwen2.5-coder:7b",
+        "reasoner": "qwen2.5:7b",
+        "skeptic": "qwen2.5:3b"
+    },
+    "high": {
+        "classifier": "qwen2.5:3b",
+        "coder": "qwen2.5-coder:14b",
+        "reasoner": "qwen2.5:14b",
+        "skeptic": "qwen2.5:7b"
+    },
+    "workstation": {
+        "classifier": "qwen2.5:7b",
+        "coder": "qwen2.5-coder:32b",
+        "reasoner": "qwen2.5:32b",
+        "skeptic": "qwen2.5:14b"
+    },
+    "datacenter": {
+        "classifier": "qwen2.5:14b",
+        "coder": "qwen2.5-coder:32b",
+        "reasoner": "qwen2.5:72b",
+        "skeptic": "qwen2.5:32b"
+    }
+}
+
+class GPUTierDetector:
+    @staticmethod
+    def get_tier_by_vram(vram_gb: float) -> str:
+        if vram_gb < 6.0:
+            return "entry"
+        elif vram_gb < 12.0:
+            return "mid"
+        elif vram_gb < 20.0:
+            return "high"
+        elif vram_gb < 48.0:
+            return "workstation"
+        else:
+            return "datacenter"
+
+    @staticmethod
+    def get_max_model_size_by_tier(tier: str) -> float:
+        mapping = {
+            "entry": 3.0,
+            "mid": 7.0,
+            "high": 14.0,
+            "workstation": 32.0,
+            "datacenter": 72.0
+        }
+        return mapping.get(tier, 3.0)
+
+    @classmethod
+    def detect(cls) -> GPUTier:
+        if not shutil.which("nvidia-smi"):
+            # Fallback for CPU / non-NVIDIA environments
+            return GPUTier(
+                name="CPU / Non-NVIDIA GPU",
+                vram_gb=0.0,
+                tier="entry",
+                max_model_size=3.0
+            )
+
+        try:
+            # Query nvidia-smi for total VRAM (in MiB) and GPU Name
+            res = subprocess.run(
+                ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader,nounits"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            output = res.stdout.strip()
+            if not output:
+                raise ValueError("Empty output from nvidia-smi")
+
+            # In case of multi-GPU, take the first one
+            first_line = output.splitlines()[0]
+            parts = first_line.split(",")
+            if len(parts) < 2:
+                raise ValueError(f"Unexpected nvidia-smi output format: {first_line}")
+
+            gpu_name = parts[0].strip()
+            vram_mib = float(parts[1].strip())
+            vram_gb = vram_mib / 1024.0
+
+            tier = cls.get_tier_by_vram(vram_gb)
+            max_model_size = cls.get_max_model_size_by_tier(tier)
+
+            return GPUTier(
+                name=gpu_name,
+                vram_gb=vram_gb,
+                tier=tier,
+                max_model_size=max_model_size
+            )
+        except Exception:
+            # Graceful degradation on query failure
+            return GPUTier(
+                name="NVIDIA GPU (Detection Failed)",
+                vram_gb=4.0,
+                tier="entry",
+                max_model_size=3.0
+            )

ghostcoder/config.py

@@ -1,6 +1,7 @@
 import os
 import pathlib
 import yaml
+from typing import Optional
 
 DEFAULT_CONFIG = {
     "ollama_url": "http://localhost:11434",
@@ -14,6 +15,11 @@
     "skeptic": True,
     "gemini_api_key": "",
     "use_gemini_fallback": False,
+    "gpu_tier": "auto",
+    "model_classifier": "",
+    "model_coder": "",
+    "model_reasoner": "",
+    "model_skeptic": "",
     "agent_mappings": {
         "errors": [
             {"pattern": "FAILED tests/", "agents": ["agency-reality-checker", "agency-senior-developer"]},
@@ -47,24 +53,61 @@
 
 class Config:
     def __init__(self, config_path=None):
-        self.config_path = config_path or os.path.expanduser("~/.ghostcoder/config.yaml")
         self.data = DEFAULT_CONFIG.copy()
+        self.global_config_path = os.path.expanduser("~/.ghostcoder/config.yaml")
+        self.local_config_path = self._find_local_config()
+        
+        if config_path:
+            self.config_path = config_path
+        else:
+            self.config_path = self.local_config_path or self.global_config_path
+            
         self.load()
 
+    def _find_local_config(self) -> Optional[str]:
+        # Walk up to find .ghostcoder/config.yml or config.yaml
+        try:
+            curr = pathlib.Path(os.getcwd()).resolve()
+            for parent in [curr] + list(curr.parents):
+                for filename in ["config.yml", "config.yaml"]:
+                    p = parent / ".ghostcoder" / filename
+                    if p.exists() and p.is_file():
+                        return str(p)
+        except Exception:
+            pass
+        return None
+
     def load(self):
-        path = pathlib.Path(self.config_path)
-        if path.exists():
+        # 1. Load global
+        global_path = pathlib.Path(self.global_config_path)
+        if global_path.exists():
             try:
-                with open(path, "r", encoding="utf-8") as f:
+                with open(global_path, "r", encoding="utf-8") as f:
                     user_data = yaml.safe_load(f)
                     if user_data:
                         self._merge(self.data, user_data)
             except Exception as e:
-                print(f"Error loading config file: {e}")
+                print(f"Error loading global config: {e}")
         else:
-            # Ensure folder exists
-            path.parent.mkdir(parents=True, exist_ok=True)
-            self.save()
+            # Create global directory and file on first run
+            try:
+                global_path.parent.mkdir(parents=True, exist_ok=True)
+                with open(global_path, "w", encoding="utf-8") as f:
+                    yaml.safe_dump(DEFAULT_CONFIG, f)
+            except Exception:
+                pass
+
+        # 2. Load local
+        if self.local_config_path:
+            local_path = pathlib.Path(self.local_config_path)
+            if local_path.exists():
+                try:
+                    with open(local_path, "r", encoding="utf-8") as f:
+                        user_data = yaml.safe_load(f)
+                        if user_data:
+                            self._merge(self.data, user_data)
+                except Exception as e:
+                    print(f"Error loading local config: {e}")
 
     def _merge(self, base, update):
         for k, v in update.items():
@@ -107,13 +150,66 @@ def vram_headroom_mb(self):
     def coder_idle_timeout(self):
         return self.data.get("coder_idle_timeout", 30.0)
 
+    def resolve_model(self, role: str) -> str:
+        # 1. Check for manual override in config
+        override_key = f"model_{role}"
+        if self.data.get(override_key):
+            return self.data[override_key]
+        
+        # 2. Check for backward compatibility with old config keys
+        if role == "classifier" and self.data.get("classifier_model"):
+            if self.data["classifier_model"] != DEFAULT_CONFIG["classifier_model"]:
+                return self.data["classifier_model"]
+        if role == "coder" and self.data.get("coder_model"):
+            if self.data["coder_model"] != DEFAULT_CONFIG["coder_model"]:
+                return self.data["coder_model"]
+
+        # 3. Detect GPU and use preset
+        from .backends.gpu_tier import GPUTierDetector, MODEL_PRESETS
+        
+        configured_tier = self.gpu_tier
+        if configured_tier == "auto":
+            gpu_info = GPUTierDetector.detect()
+            configured_tier = gpu_info.tier
+            
+        presets = MODEL_PRESETS.get(configured_tier, MODEL_PRESETS["entry"])
+        return presets.get(role, "")
+
+    @property
+    def gpu_tier(self):
+        return self.data.get("gpu_tier", "auto")
+
+    @property
+    def model_classifier(self):
+        return self.data.get("model_classifier", "")
+
+    @property
+    def model_coder(self):
+        return self.data.get("model_coder", "")
+
+    @property
+    def model_reasoner(self):
+        return self.data.get("model_reasoner", "")
+
+    @property
+    def model_skeptic(self):
+        return self.data.get("model_skeptic", "")
+
     @property
     def classifier_model(self):
-        return self.data.get("classifier_model", "qwen2.5:0.5b")
+        return self.resolve_model("classifier")
 
     @property
     def coder_model(self):
-        return self.data.get("coder_model", "qwen2.5-coder:1.5b")
+        return self.resolve_model("coder")
+
+    @property
+    def reasoner_model(self):
+        return self.resolve_model("reasoner")
+
+    @property
+    def skeptic_model(self):
+        return self.resolve_model("skeptic")
 
     @property
     def skeptic(self):