llm-checker 3.2.0 → 3.2.2

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "llm-checker",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "Intelligent CLI tool with AI-powered model selection that analyzes your hardware and recommends optimal LLM models for your system",
   "bin": {
-    "llm-checker": "bin/enhanced_cli.js",
-    "ollama-checker": "bin/enhanced_cli.js",
+    "llm-checker": "bin/cli.js",
+    "ollama-checker": "bin/cli.js",
     "llm-checker-mcp": "bin/mcp-server.mjs"
   },
   "main": "src/index.js",
@@ -13,6 +13,13 @@
     "test:gpu": "node tests/gpu-detection/multi-gpu.test.js",
     "test:platform": "node tests/platform-tests/cross-platform.test.js",
     "test:ui": "node tests/ui-tests/interface.test.js",
+    "test:runtime": "node tests/runtime-specdec-tests.js",
+    "test:deterministic-pool": "node tests/deterministic-model-pool-check.js",
+    "test:policy": "node tests/policy-commands.test.js",
+    "test:policy-cli": "node tests/policy-cli-enforcement.js",
+    "test:policy-engine": "node tests/policy-engine.test.js",
+    "test:policy-e2e": "node tests/policy-e2e-integration.test.js",
+    "test:hardware-detector": "node tests/hardware-detector-regression.js",
     "test:all": "node tests/run-all-tests.js",
     "build": "echo 'No build needed'",
     "dev": "node bin/enhanced_cli.js",
@@ -36,6 +43,7 @@
     "ora": "^5.4.1",
     "systeminformation": "^5.21.0",
     "table": "^6.8.1",
+    "yaml": "^2.8.1",
     "zod": "^3.23.0"
   },
   "optionalDependencies": {

package/src/ai/multi-objective-selector.js

@@ -387,6 +387,9 @@ class MultiObjectiveSelector {
         // 2) Memory bandwidth (20%) - simplified estimation
         let memBandwidthGBs = 50; // fallback
         const gpu = gpuModel.toLowerCase();
+        if (gpu.includes('gb10') || gpu.includes('grace blackwell') || gpu.includes('dgx spark')) memBandwidthGBs = 1000;
+        else if (gpu.includes('h100')) memBandwidthGBs = 3000;
+        else if (gpu.includes('a100')) memBandwidthGBs = 2039;
         if (gpu.includes('m4 pro')) memBandwidthGBs = 273;
         else if (gpu.includes('m4')) memBandwidthGBs = 120;
         else if (gpu.includes('rtx 4090')) memBandwidthGBs = 1008;
@@ -398,7 +401,10 @@ class MultiObjectiveSelector {
         
         // 3) Compute (20%) - simplified estimation
         let compute = 0;
-        if (gpu.includes('m4 pro')) compute = clamp(28 / 80);  // Match main algorithm
+        if (gpu.includes('gb10') || gpu.includes('grace blackwell') || gpu.includes('dgx spark')) compute = clamp(180 / 80);
+        else if (gpu.includes('h100')) compute = clamp(320 / 80);
+        else if (gpu.includes('a100')) compute = clamp(250 / 80);
+        else if (gpu.includes('m4 pro')) compute = clamp(28 / 80);  // Match main algorithm
         else if (gpu.includes('m4')) compute = clamp(15 / 80);
         else if (gpu.includes('rtx 4090')) compute = clamp(165 / 80);
         else if (gpu.includes('rtx 4080')) compute = clamp(121 / 80);
@@ -448,6 +454,10 @@ class MultiObjectiveSelector {
         
         // Special flagship GPU detection by model name
         if (gpuModel.toLowerCase().includes('rtx 50') || 
+            gpuModel.toLowerCase().includes('gb10') ||
+            gpuModel.toLowerCase().includes('grace blackwell') ||
+            gpuModel.toLowerCase().includes('dgx spark') ||
+            gpuModel.toLowerCase().includes('blackwell') ||
             gpuModel.toLowerCase().includes('h100') || 
             gpuModel.toLowerCase().includes('a100')) {
             tier = 'flagship';
@@ -599,7 +609,11 @@ class MultiObjectiveSelector {
         
         // NVIDIA GPU optimizations
         if (gpu.includes('nvidia') || gpu.includes('geforce') || gpu.includes('rtx') || gpu.includes('gtx')) {
-            if (gpu.includes('rtx 50')) {
+            if (gpu.includes('gb10') || gpu.includes('grace blackwell') || gpu.includes('dgx spark')) {
+                specs.offloadCapacity = Math.min(ramGB * 0.6, 32);
+                specs.memoryEfficiency = 0.96;
+                specs.backendOptimization = 1.25;
+            } else if (gpu.includes('rtx 50')) {
                 // RTX 50xx series - flagship tier with massive VRAM + excellent offload
                 specs.offloadCapacity = Math.min(ramGB * 0.5, 24);
                 specs.memoryEfficiency = 0.95;
@@ -732,7 +746,15 @@ class MultiObjectiveSelector {
         // GPU-based calculation (dedicated GPU only)
         if (vramGB > 0 && !gpuModel.toLowerCase().includes('iris') && !gpuModel.toLowerCase().includes('integrated')) {
             let gpuTPS = 20; // Conservative GPU baseline
-            if (gpuModel.toLowerCase().includes('rtx 50')) {
+            if (gpuModel.toLowerCase().includes('gb10') ||
+                gpuModel.toLowerCase().includes('grace blackwell') ||
+                gpuModel.toLowerCase().includes('dgx spark')) {
+                gpuTPS = 85; // GB10 / Grace Blackwell class
+            } else if (gpuModel.toLowerCase().includes('h100')) {
+                gpuTPS = 120;
+            } else if (gpuModel.toLowerCase().includes('a100')) {
+                gpuTPS = 95;
+            } else if (gpuModel.toLowerCase().includes('rtx 50')) {
                 gpuTPS = 60; // RTX 50 series - more realistic
             } else if (gpuModel.toLowerCase().includes('rtx 40')) {
                 gpuTPS = 45; // RTX 40 series  
@@ -740,6 +762,8 @@ class MultiObjectiveSelector {
                 gpuTPS = 35; // RTX 30 series
             } else if (gpuModel.toLowerCase().includes('rtx 20')) {
                 gpuTPS = 25; // RTX 20 series
+            } else if (gpuModel.toLowerCase().includes('p100')) {
+                gpuTPS = 32; // Tesla P100 class
             } else if (vramGB >= 8) {
                 gpuTPS = 30; // Other high-end GPUs
             } else if (vramGB >= 4) {
@@ -817,4 +841,4 @@ class MultiObjectiveSelector {
     }
 }
 
-module.exports = MultiObjectiveSelector;
+module.exports = MultiObjectiveSelector;

package/src/hardware/backends/cuda-detector.js

@@ -209,8 +209,34 @@ class CUDADetector {
             architecture: 'Unknown'
         };
 
+        // NVIDIA GB10 / Grace Blackwell (DGX Spark)
+        if (nameLower.includes('gb10') || nameLower.includes('grace blackwell') ||
+            nameLower.includes('dgx spark') || nameLower.includes('blackwell')) {
+            capabilities.tensorCores = true;
+            capabilities.bf16 = true;
+            capabilities.fp8 = true;
+            capabilities.computeCapability = '10.0';
+            capabilities.architecture = 'Grace Blackwell';
+        }
+        // H100 (Hopper)
+        else if (nameLower.includes('h100') || nameLower.includes('h200')) {
+            capabilities.tensorCores = true;
+            capabilities.bf16 = true;
+            capabilities.fp8 = true;
+            capabilities.nvlink = true;
+            capabilities.computeCapability = '9.0';
+            capabilities.architecture = 'Hopper';
+        }
+        // Tesla P100 (Pascal)
+        else if (nameLower.includes('p100') || nameLower.includes('tesla p100')) {
+            capabilities.tensorCores = false;
+            capabilities.bf16 = false;
+            capabilities.fp8 = false;
+            capabilities.computeCapability = '6.0';
+            capabilities.architecture = 'Pascal';
+        }
         // RTX 50 series (Blackwell)
-        if (nameLower.includes('rtx 50') || nameLower.includes('rtx50')) {
+        else if (nameLower.includes('rtx 50') || nameLower.includes('rtx50')) {
             capabilities.tensorCores = true;
             capabilities.bf16 = true;
             capabilities.fp8 = true;
@@ -257,15 +283,6 @@ class CUDADetector {
             capabilities.architecture = 'Volta';
             capabilities.nvlink = true;
         }
-        // H100 (Hopper)
-        else if (nameLower.includes('h100') || nameLower.includes('h200')) {
-            capabilities.tensorCores = true;
-            capabilities.bf16 = true;
-            capabilities.fp8 = true;
-            capabilities.nvlink = true;
-            capabilities.computeCapability = '9.0';
-            capabilities.architecture = 'Hopper';
-        }
 
         return capabilities;
     }
@@ -311,6 +328,9 @@ class CUDADetector {
             'rtx 2060': 80,
 
             // Data center
+            'gb10': 95,
+            'grace blackwell': 95,
+            'dgx spark': 95,
             'h100': 400,
             'h200': 450,
             'a100': 300,
@@ -318,7 +338,8 @@ class CUDADetector {
             'l4': 150,
             'a40': 180,
             't4': 70,
-            'v100': 120
+            'v100': 120,
+            'p100': 45
         };
 
         for (const [model, speed] of Object.entries(speedMap)) {

package/src/hardware/detector.js

@@ -1,10 +1,12 @@
 const si = require('systeminformation');
+const UnifiedDetector = require('./unified-detector');
 
 class HardwareDetector {
     constructor() {
         this.cache = null;
         this.cacheExpiry = 5 * 60 * 1000;
         this.cacheTime = 0;
+        this.unifiedDetector = new UnifiedDetector();
     }
 
     async getSystemInfo(forceFresh = false) {
@@ -31,6 +33,8 @@ class HardwareDetector {
                 timestamp: Date.now()
             };
 
+            await this.enrichWithUnifiedHardware(systemInfo);
+
             this.cache = systemInfo;
             this.cacheTime = Date.now();
 
@@ -93,9 +97,15 @@ class HardwareDetector {
         const validGPUs = controllers.filter(gpu => {
             const model = (gpu.model || '').toLowerCase();
             const vendor = (gpu.vendor || '').toLowerCase();
+            const hasKnownModelSignature = this.looksLikeRealGPUModel(model);
             
             // Skip GPUs with empty/invalid data (like virtualized GPUs)
-            if (!model || !vendor || model === 'unknown' || vendor === '') {
+            if (!model || model === 'unknown') {
+                return false;
+            }
+
+            // Some passthrough/virtualized setups report empty vendor while model is valid
+            if ((!vendor || vendor === '') && !hasKnownModelSignature) {
                 return false;
             }
             
@@ -181,7 +191,7 @@ class HardwareDetector {
 
         return {
             model: enhancedModel,
-            vendor: primaryGPU.vendor || 'Unknown',
+            vendor: primaryGPU.vendor || this.inferVendorFromGPUModel(enhancedModel, 'Unknown'),
             vram: effectiveVRAM,
             vramPerGPU: vram, // VRAM of primary GPU for reference
             vramDynamic: primaryGPU.vramDynamic || false,
@@ -192,13 +202,54 @@ class HardwareDetector {
             all: controllers.map(gpu => ({
                 model: gpu.model,
                 vram: this.normalizeVRAM(gpu.vram || 0),
-                vendor: gpu.vendor
+                vendor: gpu.vendor || this.inferVendorFromGPUModel(gpu.model, 'Unknown')
             })),
             displays: displays.length,
             score: this.calculateGPUScore(primaryGPU)
         };
     }
 
+    async enrichWithUnifiedHardware(systemInfo) {
+        try {
+            const unified = await this.unifiedDetector.detect();
+            if (!unified || !unified.summary || !unified.primary) {
+                return;
+            }
+
+            const primaryType = unified.primary.type || 'cpu';
+            if (primaryType === 'cpu') {
+                return;
+            }
+
+            const summary = unified.summary;
+            const backendInfo = unified.backends?.[primaryType]?.info || {};
+            const backendGPUs = Array.isArray(backendInfo.gpus) ? backendInfo.gpus : [];
+            const gpuCount = summary.gpuCount || backendGPUs.length || systemInfo.gpu.gpuCount || 1;
+
+            const totalVRAM = typeof summary.totalVRAM === 'number' ? summary.totalVRAM : systemInfo.gpu.vram;
+            const perGPUVRAM = backendGPUs[0]?.memory?.total
+                || (gpuCount > 0 && totalVRAM > 0 ? Math.round(totalVRAM / gpuCount) : 0);
+
+            const modelFromUnified = summary.gpuModel || systemInfo.gpu.model;
+            const vendor = this.inferVendorFromGPUModel(modelFromUnified, systemInfo.gpu.vendor);
+
+            systemInfo.gpu = {
+                ...systemInfo.gpu,
+                model: modelFromUnified,
+                vendor,
+                vram: totalVRAM || systemInfo.gpu.vram,
+                vramPerGPU: perGPUVRAM || systemInfo.gpu.vramPerGPU || 0,
+                dedicated: primaryType !== 'metal',
+                gpuCount,
+                isMultiGPU: Boolean(summary.isMultiGPU || gpuCount > 1),
+                backend: primaryType,
+                driverVersion: backendInfo.driver || systemInfo.gpu.driverVersion
+            };
+        } catch (error) {
+            // Keep systeminformation-only results when backend-specific detection is unavailable
+        }
+    }
+
     processSystemInfo(system) {
         return {
             manufacturer: system.manufacturer || 'Unknown',
@@ -298,6 +349,10 @@ class HardwareDetector {
     estimateVRAMFromModel(model) {
         if (!model) return 0;
         const modelLower = model.toLowerCase();
+
+        // NVIDIA data-center / workstation
+        if (modelLower.includes('gb10') || modelLower.includes('grace blackwell') || modelLower.includes('dgx spark')) return 96;
+        if (modelLower.includes('tesla p100') || modelLower.includes('p100')) return 16;
         
         // NVIDIA RTX 50 series
         if (modelLower.includes('rtx 5090')) return 32;
@@ -398,6 +453,7 @@ class HardwareDetector {
 
         // Bonus por marcas/modelos específicos
         if (model.includes('rtx 5090')) score += 30;
+        else if (model.includes('gb10') || model.includes('grace blackwell') || model.includes('dgx spark')) score += 28;
         else if (model.includes('rtx 5080')) score += 27;
         else if (model.includes('rtx 5070')) score += 24;
         else if (model.includes('rtx 5060')) score += 21;
@@ -407,6 +463,7 @@ class HardwareDetector {
         else if (model.includes('rtx 30')) score += 18;
         else if (model.includes('rtx 20')) score += 15;
         else if (model.includes('gtx 16')) score += 12;
+        else if (model.includes('tesla p100') || model.includes('p100')) score += 14;
         else if (model.includes('apple m')) score += 15;
 
         return Math.min(Math.round(score), 100);
@@ -497,9 +554,10 @@ class HardwareDetector {
      */
     getGPUTier(model) {
         const modelLower = model.toLowerCase();
-        
+
         // NVIDIA RTX series
         if (modelLower.includes('rtx 50')) return 100;
+        if (modelLower.includes('gb10') || modelLower.includes('grace blackwell') || modelLower.includes('dgx spark')) return 98;
         if (modelLower.includes('rtx 4090')) return 95;
         if (modelLower.includes('rtx 40')) return 90;
         if (modelLower.includes('rtx 3090')) return 85;
@@ -511,6 +569,7 @@ class HardwareDetector {
         // NVIDIA Professional
         if (modelLower.includes('a100')) return 98;
         if (modelLower.includes('h100')) return 99;
+        if (modelLower.includes('tesla p100') || modelLower.includes('p100')) return 78;
         if (modelLower.includes('tesla')) return 75;
         if (modelLower.includes('quadro')) return 65;
         
@@ -545,6 +604,49 @@ class HardwareDetector {
         return 0;
     }
 
+    looksLikeRealGPUModel(model) {
+        if (!model) return false;
+        const modelLower = model.toLowerCase();
+
+        const gpuMarkers = [
+            'nvidia', 'geforce', 'rtx', 'gtx', 'tesla', 'quadro',
+            'amd', 'radeon', 'rx ', 'instinct',
+            'intel', 'arc', 'iris', 'uhd',
+            'apple', 'm1', 'm2', 'm3', 'm4',
+            'gb10', 'blackwell'
+        ];
+
+        return gpuMarkers.some(marker => modelLower.includes(marker));
+    }
+
+    inferVendorFromGPUModel(model, fallback = 'Unknown') {
+        if (!model) return fallback;
+        const modelLower = model.toLowerCase();
+
+        if (modelLower.includes('nvidia') || modelLower.includes('geforce') ||
+            modelLower.includes('rtx') || modelLower.includes('gtx') ||
+            modelLower.includes('tesla') || modelLower.includes('quadro') ||
+            modelLower.includes('gb10') || modelLower.includes('blackwell')) {
+            return 'NVIDIA';
+        }
+
+        if (modelLower.includes('amd') || modelLower.includes('radeon') || modelLower.includes('instinct')) {
+            return 'AMD';
+        }
+
+        if (modelLower.includes('intel') || modelLower.includes('arc') ||
+            modelLower.includes('iris') || modelLower.includes('uhd')) {
+            return 'Intel';
+        }
+
+        if (modelLower.includes('apple') || modelLower.includes('m1') ||
+            modelLower.includes('m2') || modelLower.includes('m3') || modelLower.includes('m4')) {
+            return 'Apple';
+        }
+
+        return fallback;
+    }
+
     async runQuickBenchmark() {
 
         const start = process.hrtime.bigint();
@@ -576,4 +678,4 @@ class HardwareDetector {
 
 }
 
-module.exports = HardwareDetector;
+module.exports = HardwareDetector;

package/src/hardware/specs.js

@@ -71,6 +71,13 @@ class HardwareSpecs {
             'NVIDIA GeForce RTX 3060 Ti': { score: 75, vram: 8, tdp: 200, dedicated: true },
             'NVIDIA GeForce RTX 3060': { score: 70, vram: 12, tdp: 170, dedicated: true },
 
+            // NVIDIA Data Center / Workstation
+            'NVIDIA H100': { score: 100, vram: 80, tdp: 700, dedicated: true },
+            'NVIDIA A100': { score: 94, vram: 80, tdp: 400, dedicated: true },
+            'NVIDIA Tesla P100': { score: 74, vram: 16, tdp: 250, dedicated: true },
+            'NVIDIA GB10 Grace Blackwell': { score: 96, vram: 96, tdp: 140, dedicated: true },
+            'NVIDIA DGX Spark (GB10)': { score: 96, vram: 96, tdp: 140, dedicated: true },
+
             // AMD RX 7000 Series
             'AMD Radeon RX 7900 XTX': { score: 92, vram: 24, tdp: 355, dedicated: true },
             'AMD Radeon RX 7900 XT': { score: 88, vram: 20, tdp: 300, dedicated: true },
@@ -283,4 +290,4 @@ class HardwareSpecs {
     }
 }
 
-module.exports = HardwareSpecs;
+module.exports = HardwareSpecs;