llm-checker 3.5.11 → 3.5.12

package/bin/enhanced_cli.js

@@ -881,6 +881,11 @@ function formatGpuInventoryList(models = []) {
 
 // Helper function to get hardware tier for display
 function getHardwareTierForDisplay(hardware) {
+    const canonicalTier = hardware?.summary?.hardwareTier;
+    if (typeof canonicalTier === 'string' && canonicalTier.trim()) {
+        return canonicalTier.replace(/_/g, ' ').toUpperCase();
+    }
+
     const ram = hardware.memory.total;
     const cores = hardware.cpu.cores;
     const gpuModel = hardware.gpu?.model || '';
@@ -923,6 +928,21 @@ function getHardwareTierForDisplay(hardware) {
     return tier;
 }
 
+function getBackendLabelForDisplay(hardware) {
+    const summary = hardware?.summary || {};
+
+    if (typeof summary.bestBackendLabel === 'string' && summary.bestBackendLabel.trim()) {
+        return summary.bestBackendLabel;
+    }
+
+    const backendName = summary.backendName || String(summary.bestBackend || 'cpu').toUpperCase();
+    if (summary.runtimeBackend && summary.runtimeBackend !== summary.bestBackend) {
+        return `${backendName} + ${summary.runtimeBackendName || summary.runtimeBackend} assist`;
+    }
+
+    return backendName;
+}
+
 function formatSpeed(speed) {
     const speedMap = {
         'very_fast': 'very_fast',
@@ -969,12 +989,13 @@ function displaySystemInfo(hardware, analysis) {
         `${chalk.cyan('Architecture:')} ${hardware.cpu.architecture}`,
         `${chalk.cyan('RAM:')} ${ramColor(hardware.memory.total + 'GB')}`,
         `${chalk.cyan('GPU:')} ${gpuColor(hardware.gpu.model || 'Not detected')}`,
+        `${chalk.cyan('Backend:')} ${chalk.white(getBackendLabelForDisplay(hardware))}`,
         `${chalk.cyan('VRAM:')} ${hardware.gpu.vram === 0 && hardware.gpu.model && hardware.gpu.model.toLowerCase().includes('apple') ? 'Unified Memory' : `${hardware.gpu.vram || 'N/A'}GB`}${hardware.gpu.dedicated ? chalk.green(' (Dedicated)') : chalk.hex('#FFA500')(' (Integrated)')}`,
         `${chalk.cyan('Dedicated GPUs:')} ${chalk.green(dedicatedList)}`,
         `${chalk.cyan('Integrated GPUs:')} ${chalk.hex('#FFA500')(integratedList)}`,
     ];
 
-    const tier = analysis.summary.hardwareTier?.replace('_', ' ').toUpperCase() || 'UNKNOWN';
+    const tier = analysis.summary.hardwareTier?.replace(/_/g, ' ').toUpperCase() || getHardwareTierForDisplay(hardware);
     const tierColor = tier.includes('HIGH') ? chalk.green : tier.includes('MEDIUM') ? chalk.yellow : chalk.red;
 
     lines.push(`${chalk.bold('Hardware Tier:')} ${tierColor.bold(tier)}`);
@@ -1758,6 +1779,7 @@ function displaySimplifiedSystemInfo(hardware) {
     console.log(`Memory: ${chalk.white(memInfo)}`);
     console.log(`GPU: ${chalk.white(gpuInfo)}`);
     console.log(`Architecture: ${chalk.white(hardware.cpu.architecture)}`);
+    console.log(`Backend: ${chalk.white(getBackendLabelForDisplay(hardware))}`);
     
     const tier = getHardwareTierForDisplay(hardware);
     const tierColor = tier.includes('HIGH') ? chalk.green : tier.includes('MEDIUM') ? chalk.yellow : chalk.red;
@@ -5058,7 +5080,7 @@ program
             console.log(`  ${detector.getHardwareDescription()}`);
             console.log(`  Tier: ${chalk.cyan(detector.getHardwareTier().replace('_', ' ').toUpperCase())}`);
             console.log(`  Max model size: ${chalk.green(detector.getMaxModelSize() + 'GB')}`);
-            console.log(`  Best backend: ${chalk.cyan(hardware.summary.bestBackend)}`);
+            console.log(`  Best backend: ${chalk.cyan(getBackendLabelForDisplay(hardware))}`);
             if (hardware.summary.runtimeBackend && hardware.summary.runtimeBackend !== hardware.summary.bestBackend) {
                 console.log(`  Runtime assist: ${chalk.green(hardware.summary.runtimeBackendName || hardware.summary.runtimeBackend)}`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.11",
+  "version": "3.5.12",
   "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/cli.js",

package/src/hardware/unified-detector.js

@@ -333,9 +333,38 @@ class UnifiedDetector {
             summary.effectiveMemory = Math.round(summary.systemRAM * 0.7);
         }
 
+        summary.hardwareTier = this.classifyHardwareTierFromSummary(summary);
+        summary.bestBackendLabel = this.getBestBackendLabel(summary);
+
         return summary;
     }
 
+    classifyHardwareTierFromSummary(summary = {}) {
+        const effectiveMem = Number(summary.effectiveMemory) || 0;
+        const speed = Number(summary.speedCoefficient) || 0;
+
+        if (effectiveMem >= 80 && speed >= 300) return 'ultra_high';      // H100, MI300
+        if (effectiveMem >= 48 && speed >= 200) return 'very_high';       // 2x3090, 4090
+        if (effectiveMem >= 24 && speed >= 150) return 'high';            // 3090, 4090, M2 Max
+        if (effectiveMem >= 16 && speed >= 100) return 'medium_high';     // 4080, 3080, M3 Pro
+        if (effectiveMem >= 12 && speed >= 80) return 'medium';           // 3060, 4060 Ti
+        if (effectiveMem >= 8 && speed >= 50) return 'medium_low';        // 3060, M2
+        if (effectiveMem >= 6 && speed >= 30) return 'low';               // GTX 1660, iGPU
+        return 'ultra_low';                                                // CPU only
+    }
+
+    getBestBackendLabel(summary = {}) {
+        const backendName = summary.backendName || String(summary.bestBackend || 'cpu').toUpperCase();
+        if (
+            summary.hasRuntimeAssist &&
+            summary.runtimeBackend &&
+            summary.runtimeBackend !== summary.bestBackend
+        ) {
+            return `${backendName} + ${summary.runtimeBackendName || summary.runtimeBackend} assist`;
+        }
+        return backendName;
+    }
+
     summarizeGPUInventory(gpus = []) {
         const normalized = this.normalizeGpuInventory(gpus);
         const counts = new Map();
@@ -844,19 +873,7 @@ class UnifiedDetector {
         const result = this.cache;
         if (!result) return 'unknown';
 
-        const summary = result.summary;
-        const effectiveMem = summary.effectiveMemory;
-        const speed = summary.speedCoefficient;
-
-        // Tier based on effective memory and speed
-        if (effectiveMem >= 80 && speed >= 300) return 'ultra_high';      // H100, MI300
-        if (effectiveMem >= 48 && speed >= 200) return 'very_high';       // 2x3090, 4090
-        if (effectiveMem >= 24 && speed >= 150) return 'high';            // 3090, 4090, M2 Max
-        if (effectiveMem >= 16 && speed >= 100) return 'medium_high';     // 4080, 3080, M3 Pro
-        if (effectiveMem >= 12 && speed >= 80) return 'medium';           // 3060, 4060 Ti
-        if (effectiveMem >= 8 && speed >= 50) return 'medium_low';        // 3060, M2
-        if (effectiveMem >= 6 && speed >= 30) return 'low';               // GTX 1660, iGPU
-        return 'ultra_low';                                                // CPU only
+        return result.summary?.hardwareTier || this.classifyHardwareTierFromSummary(result.summary);
     }
 
     /**

package/src/index.js

@@ -1345,9 +1345,27 @@ class LLMChecker {
     }
 
     getHardwareTier(hardware) {
+        const canonicalTier = hardware?.summary?.hardwareTier;
+        if (typeof canonicalTier === 'string' && canonicalTier.trim()) {
+            return canonicalTier.trim().toLowerCase().replace(/\s+/g, '_');
+        }
         return this.calculateHardwareScore(hardware).tier;
     }
 
+    getHardwareTierBucket(hardware) {
+        const tier = this.getHardwareTier(hardware);
+        switch (tier) {
+            case 'very_high':
+                return 'ultra_high';
+            case 'medium_high':
+                return 'high';
+            case 'medium_low':
+                return 'low';
+            default:
+                return tier;
+        }
+    }
+
     calculateHardwareScore(hardware) {
         const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
         
@@ -2003,7 +2021,7 @@ class LLMChecker {
             score -= 15;
         }
 
-        const hardwareTier = this.getHardwareTier(hardware);
+        const hardwareTier = this.getHardwareTierBucket(hardware);
         switch (hardwareTier) {
             case 'ultra_high':
                 score += 15;

package/src/models/deterministic-selector.js

@@ -2141,6 +2141,10 @@ class DeterministicModelSelector {
 
     mapHardwareTier(hardware = {}) {
         const summary = hardware?.summary || {};
+        const canonicalTier = summary.hardwareTier || summary.hardware_tier;
+        if (typeof canonicalTier === 'string' && canonicalTier.trim()) {
+            return canonicalTier.trim().toLowerCase().replace(/\s+/g, '_');
+        }
         const effectiveMemory = Number(summary.effectiveMemory);
         const speedCoefficient = Number(summary.speedCoefficient);
         if (Number.isFinite(effectiveMemory) && effectiveMemory > 0 && Number.isFinite(speedCoefficient)) {