llm-checker 3.5.11 → 3.5.13

package/src/ai/model-selector.js

@@ -33,19 +33,20 @@ class AIModelSelector {
         }
     }
 
-    async selectBestModel(candidateModels, systemSpecs = null, userPreference = 'general') {
+    async selectBestModel(candidateModels, systemSpecs = null, userPreference = 'general', options = {}) {
+        const log = options.silent ? () => {} : console.log;
+        const warn = options.silent ? () => {} : console.warn;
+
         try {
             // Para ai-run: usar TODOS los modelos de la base de datos para encontrar el mejor
             // y luego verificar si está instalado localmente
-            console.log('🔍 Using comprehensive model database for selection...');
+            log('🔍 Using comprehensive model database for selection...');
             
             // Obtener todos los modelos de la base de datos de Ollama
-            const { OllamaNativeScraper } = require('../ollama/native-scraper');
-            const scraper = new OllamaNativeScraper();
-            const allModelData = await scraper.scrapeAllModels(false);
+            const allModelData = await this.loadModelDatabase();
             const allAvailableModels = allModelData.models || [];
             
-            console.log(`Evaluating against ${allAvailableModels.length} models from database`);
+            log(`Evaluating against ${allAvailableModels.length} models from database`);
             
             // Usar el selector inteligente con TODOS los modelos disponibles
             const result = this.intelligentSelector.selectBestModels(
@@ -68,7 +69,7 @@ class AIModelSelector {
                 let reason = result.best_model.reasoning;
                 
                 if (!isLocallyInstalled) {
-                    console.log(`Best model ${recommendedId} not installed locally`);
+                    log(`Best model ${recommendedId} not installed locally`);
                     
                     // Buscar el mejor modelo entre los instalados localmente
                     const localResult = this.intelligentSelector.selectBestModels(
@@ -83,7 +84,7 @@ class AIModelSelector {
                         confidence = localResult.best_model.confidence * 0.9; // Reducir confianza
                         reason = `${localResult.best_model.reasoning} (Locally installed alternative to recommended ${recommendedId})`;
                         
-                        console.log(`🔄 Using best local alternative: ${finalModel}`);
+                        log(`🔄 Using best local alternative: ${finalModel}`);
                     }
                 }
                 
@@ -111,7 +112,7 @@ class AIModelSelector {
                 };
             }
         } catch (error) {
-            console.warn(`Comprehensive database selection failed: ${error.message}`);
+            warn(`Comprehensive database selection failed: ${error.message}`);
             
             // Fallback al método anterior con solo modelos locales
             try {
@@ -139,7 +140,7 @@ class AIModelSelector {
                     };
                 }
             } catch (localError) {
-                console.warn(`Local intelligent selection also failed: ${localError.message}`);
+                warn(`Local intelligent selection also failed: ${localError.message}`);
             }
         }
 
@@ -161,15 +162,45 @@ class AIModelSelector {
                 };
 
             } catch (error) {
-                console.warn(`ONNX AI selection failed: ${error.message}`);
+                warn(`ONNX AI selection failed: ${error.message}`);
             }
         }
 
         // Final fallback to simple heuristic
-        return this.fallbackSelection(candidateModels, systemSpecs);
+        return this.fallbackSelection(candidateModels, systemSpecs, options);
+    }
+
+    async loadModelDatabase() {
+        try {
+            const ModelDatabase = require('../data/model-database');
+            const database = new ModelDatabase();
+            await database.initialize();
+
+            try {
+                const models = database.getAllModelsWithVariants();
+                if (models.length > 0) {
+                    return {
+                        models,
+                        total_count: models.length,
+                        source: 'ollama_sqlite_database'
+                    };
+                }
+            } finally {
+                database.close();
+            }
+        } catch {
+            // Fall through to scraper cache.
+        }
+
+        const { OllamaNativeScraper } = require('../ollama/native-scraper');
+        const scraper = new OllamaNativeScraper();
+        return scraper.scrapeAllModels(false);
     }
 
-    fallbackSelection(candidateModels, systemSpecs = null) {
+    fallbackSelection(candidateModels, systemSpecs = null, options = {}) {
+        const log = options.silent ? () => {} : console.log;
+        const warn = options.silent ? () => {} : console.warn;
+
         if (!systemSpecs) {
             systemSpecs = {
                 total_ram_gb: 8,
@@ -179,7 +210,7 @@ class AIModelSelector {
             };
         }
 
-        console.log('🔄 Using fallback heuristic selection...');
+        log('🔄 Using fallback heuristic selection...');
 
         // Use intelligent selector with basic heuristic mode
         try {
@@ -202,7 +233,7 @@ class AIModelSelector {
                 };
             }
         } catch (error) {
-            console.warn(`Intelligent fallback failed: ${error.message}`);
+            warn(`Intelligent fallback failed: ${error.message}`);
         }
 
         // Ultimate fallback: simple memory-based selection
@@ -309,4 +340,4 @@ class AIModelSelector {
     }
 }
 
-module.exports = AIModelSelector;
+module.exports = AIModelSelector;

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

@@ -111,12 +111,47 @@ class MultiObjectiveSelector {
             return false; // Model too large for this tier regardless of RAM
         }
         
-        // Memory check with tier-appropriate safety margin
-        const availableMemory = hardware.memory.total * limits.availableMemoryRatio;
+        // Memory check with tier-appropriate safety margin. Dedicated GPUs can
+        // run quantized models primarily from VRAM with limited RAM offload, so
+        // using only system RAM underestimates mid-range cards such as RTX 5060.
+        const availableMemory = this.getAvailableModelMemoryGB(hardware, limits.availableMemoryRatio);
         
         return totalMemoryNeeded <= availableMemory;
     }
 
+    getAvailableModelMemoryGB(hardware, fallbackRatio = 0.7) {
+        const ramGB = Number(hardware?.memory?.total ?? hardware?.memory?.totalGB ?? 0) || 0;
+        const vramGB = Number(
+            hardware?.gpu?.vram ??
+            hardware?.gpu?.vramGB ??
+            hardware?.summary?.totalVRAM ??
+            0
+        ) || 0;
+        const hasIntegratedGPU = typeof hardware?.summary?.hasIntegratedGPU === 'boolean'
+            ? hardware.summary.hasIntegratedGPU
+            : false;
+        const hasDedicatedGPU = typeof hardware?.summary?.hasDedicatedGPU === 'boolean'
+            ? hardware.summary.hasDedicatedGPU
+            : Boolean(hardware?.gpu?.dedicated || (vramGB > 0 && !hasIntegratedGPU));
+
+        if (hasDedicatedGPU && vramGB > 0) {
+            const pcSpecs = this.getPCGPUSpecs(hardware, vramGB, ramGB);
+            const vramBudget = vramGB * (pcSpecs.memoryEfficiency || 0.85);
+            const offloadBudget = Math.min(
+                pcSpecs.offloadCapacity || 0,
+                Math.max(0, ramGB * 0.5)
+            );
+            return Math.max(vramBudget, vramBudget + offloadBudget);
+        }
+
+        const sharedMemory = Number(hardware?.summary?.integratedSharedMemory || hardware?.gpu?.sharedMemory || 0);
+        if (sharedMemory > 0 && !hasDedicatedGPU) {
+            return sharedMemory * Math.max(fallbackRatio, 0.85);
+        }
+
+        return ramGB * fallbackRatio;
+    }
+
     /**
      * Step 2: Multi-objective scoring
      */
@@ -274,8 +309,10 @@ class MultiObjectiveSelector {
                 return num / (1024 ** 3); // Convert bytes to GB
             } else if (num >= 0.1 && num <= 100) {
                 // Small numbers (0.1-100) are likely billion parameters - convert to file size
-                // Rough estimate: 1B params ≈ 2GB in Q4 quantization
-                return Math.max(0.5, num * 2);
+                // Static catalog `B` values are parameter counts. Default check
+                // recommendations target quantized local inference, where Q4
+                // artifacts are roughly 0.6-0.7GB per billion parameters.
+                return Math.max(0.5, Math.round(num * 0.65 * 10) / 10);
             } else {
                 // Fallback for edge cases
                 return Math.max(0.5, num);
@@ -329,7 +366,7 @@ class MultiObjectiveSelector {
         const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
         
         const ramGB = hardware.memory.total || 0;
-        const vramGB = hardware.gpu?.vram || 0;
+        const vramGB = hardware.gpu?.vram || hardware.gpu?.vramGB || hardware.summary?.totalVRAM || 0;
         const cpuModel = hardware.cpu?.brand || hardware.cpu?.model || '';
         const gpuModel = hardware.gpu?.model || '';
         const architecture = hardware.cpu?.architecture || hardware.cpu?.brand || '';
@@ -406,6 +443,7 @@ class MultiObjectiveSelector {
         else if (gpu.includes('rtx 4090')) memBandwidthGBs = 1008;
         else if (gpu.includes('rtx 4080')) memBandwidthGBs = 716;
         else if (gpu.includes('rtx 4070')) memBandwidthGBs = 448;
+        else if (gpu.includes('rtx 5060')) memBandwidthGBs = 336;
         else if (gpu.includes('iris xe')) memBandwidthGBs = 68;
         
         const mem_bw = clamp(memBandwidthGBs / 500);  // Match main algorithm
@@ -419,6 +457,7 @@ class MultiObjectiveSelector {
         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);
+        else if (gpu.includes('rtx 5060')) compute = clamp(38 / 80);
         else if (gpu.includes('iris xe')) compute = 0.02;
         else {
             // CPU fallback
@@ -464,7 +503,7 @@ class MultiObjectiveSelector {
         }
         
         // Special flagship GPU detection by model name
-        if (gpuModel.toLowerCase().includes('rtx 50') || 
+        if (gpuModel.toLowerCase().includes('rtx 5090') ||
             gpuModel.toLowerCase().includes('gb10') ||
             gpuModel.toLowerCase().includes('grace blackwell') ||
             gpuModel.toLowerCase().includes('dgx spark') ||
@@ -472,6 +511,10 @@ class MultiObjectiveSelector {
             gpuModel.toLowerCase().includes('h100') || 
             gpuModel.toLowerCase().includes('a100')) {
             tier = 'flagship';
+        } else if (gpuModel.toLowerCase().includes('rtx 5080')) {
+            tier = bumpTier(tier, tier === 'ultra_high' || tier === 'flagship' ? 0 : +1);
+        } else if (gpuModel.toLowerCase().includes('rtx 5070') && !gpuModel.toLowerCase().includes('rtx 5070 ti')) {
+            tier = bumpTier(tier, tier === 'high' || tier === 'ultra_high' || tier === 'flagship' ? 0 : +1);
         }
         
         return tier;
@@ -624,10 +667,13 @@ class MultiObjectiveSelector {
                 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
+            } else if (gpu.includes('rtx 5090') || gpu.includes('rtx 5080') || gpu.includes('rtx 5070')) {
+                // Upper RTX 50xx cards have excellent offload behavior.
                 specs.offloadCapacity = Math.min(ramGB * 0.5, 24);
                 specs.memoryEfficiency = 0.95;
+            } else if (gpu.includes('rtx 5060')) {
+                specs.offloadCapacity = Math.min(ramGB * 0.35, 12);
+                specs.memoryEfficiency = 0.90;
             } else if (gpu.includes('rtx 40')) {
                 specs.offloadCapacity = Math.min(ramGB * 0.35, 16);
                 specs.memoryEfficiency = 0.90;
@@ -751,7 +797,7 @@ class MultiObjectiveSelector {
         const gpuModel = hardware.gpu?.model || '';
         const cores = hardware.cpu?.physicalCores || hardware.cpu?.cores || 1;
         const baseSpeed = hardware.cpu?.speed || 2.0;
-        const vramGB = hardware.gpu?.vram || 0;
+        const vramGB = hardware.gpu?.vram || hardware.gpu?.vramGB || hardware.summary?.totalVRAM || 0;
         const hasIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
             ? hardware.summary.hasIntegratedGPU
             : false;

package/src/data/model-database.js

@@ -10,10 +10,23 @@ const fs = require('fs');
 class ModelDatabase {
     constructor(options = {}) {
         this.dbPath = options.dbPath || path.join(os.homedir(), '.llm-checker', 'models.db');
+        this.seedDbPath = options.seedDbPath || path.join(__dirname, 'seed', 'models.db');
         this.db = null;
         this.initialized = false;
     }
 
+    /**
+     * Seed a first-run user database from the packaged npm snapshot.
+     */
+    seedDatabaseIfNeeded() {
+        if (fs.existsSync(this.dbPath) || !fs.existsSync(this.seedDbPath)) {
+            return false;
+        }
+
+        fs.copyFileSync(this.seedDbPath, this.dbPath);
+        return true;
+    }
+
     /**
      * Initialize database with schema
      */
@@ -25,6 +38,7 @@ class ModelDatabase {
         if (!fs.existsSync(dbDir)) {
             fs.mkdirSync(dbDir, { recursive: true });
         }
+        this.seedDatabaseIfNeeded();
 
         // Use sql.js (optional dependency)
         let initSqlJs;
@@ -229,18 +243,20 @@ class ModelDatabase {
             { pattern: /llama3\.1/, family: 'llama3.1' },
             { pattern: /llama3/, family: 'llama3' },
             { pattern: /llama2/, family: 'llama2' },
+            { pattern: /qwen3/, family: 'qwen3' },
             { pattern: /qwen2\.5/, family: 'qwen2.5' },
             { pattern: /qwen2/, family: 'qwen2' },
             { pattern: /qwen/, family: 'qwen' },
             { pattern: /mistral/, family: 'mistral' },
             { pattern: /mixtral/, family: 'mixtral' },
+            { pattern: /gemma3/, family: 'gemma3' },
             { pattern: /gemma2/, family: 'gemma2' },
             { pattern: /gemma/, family: 'gemma' },
             { pattern: /phi-?3/, family: 'phi3' },
             { pattern: /phi-?4/, family: 'phi4' },
             { pattern: /phi/, family: 'phi' },
-            { pattern: /deepseek-?coder/, family: 'deepseek-coder' },
             { pattern: /deepseek-?r1/, family: 'deepseek-r1' },
+            { pattern: /deepseek-?coder/, family: 'deepseek-coder' },
             { pattern: /deepseek/, family: 'deepseek' },
             { pattern: /codellama/, family: 'codellama' },
             { pattern: /starcoder/, family: 'starcoder' },
@@ -251,6 +267,7 @@ class ModelDatabase {
             { pattern: /neural-chat/, family: 'neural-chat' },
             { pattern: /orca/, family: 'orca' },
             { pattern: /vicuna/, family: 'vicuna' },
+            { pattern: /yi-?coder/, family: 'yi-coder' },
             { pattern: /yi/, family: 'yi' },
             { pattern: /solar/, family: 'solar' },
             { pattern: /command-r/, family: 'command-r' },
@@ -540,6 +557,80 @@ class ModelDatabase {
         return this.all(sql, params);
     }
 
+    /**
+     * Export the synced SQLite catalog in the shape expected by recommendation engines.
+     */
+    getAllModelsWithVariants() {
+        const models = this.all(`SELECT * FROM models ORDER BY pulls DESC, id ASC`);
+        const variants = this.all(`SELECT * FROM variants ORDER BY model_id ASC, params_b DESC, size_gb ASC`);
+        const variantsByModel = new Map();
+
+        const parseJson = (value, fallback) => {
+            if (!value) return fallback;
+            try {
+                const parsed = JSON.parse(value);
+                return parsed;
+            } catch {
+                return fallback;
+            }
+        };
+
+        for (const variant of variants) {
+            const list = variantsByModel.get(variant.model_id) || [];
+            const inputTypes = parseJson(variant.input_types, ['text']);
+            list.push({
+                model_id: variant.model_id,
+                tag: variant.tag,
+                params_b: variant.params_b,
+                quant: variant.quant,
+                quantization: variant.quant,
+                size_gb: variant.size_gb,
+                real_size_gb: variant.size_gb,
+                estimated_size_gb: variant.size_gb,
+                context_length: variant.context_length,
+                input_types: Array.isArray(inputTypes) ? inputTypes : ['text'],
+                is_moe: Boolean(variant.is_moe),
+                expert_count: variant.expert_count
+            });
+            variantsByModel.set(variant.model_id, list);
+        }
+
+        return models.map((model) => {
+            const capabilities = parseJson(model.capabilities, []);
+            const capabilityList = Array.isArray(capabilities) ? capabilities : [];
+            const primaryCategory =
+                capabilityList.find((cap) => ['coding', 'reasoning', 'multimodal', 'embeddings', 'creative', 'chat'].includes(cap)) ||
+                (capabilityList.includes('multimodal') ? 'multimodal' : 'general');
+
+            return {
+                id: model.id,
+                model_identifier: model.id,
+                model_name: model.name || model.id,
+                family: model.family || this.inferFamily(model.id),
+                model_type: model.type || 'official',
+                type: model.type || 'official',
+                description: model.description || '',
+                capabilities: capabilityList,
+                categories: capabilityList,
+                primary_category: primaryCategory,
+                use_cases: capabilityList,
+                pulls: model.pulls || 0,
+                actual_pulls: model.pulls || 0,
+                tags_count: model.tags_count || 0,
+                namespace: model.namespace || '',
+                url: model.url || `https://ollama.com/library/${model.id}`,
+                last_updated: model.last_updated || '',
+                updated_at: model.updated_at || '',
+                variants: variantsByModel.get(model.id) || [],
+                source: 'ollama_sqlite_database',
+                registry: 'ollama.com',
+                version: model.updated_at || model.last_updated || 'unknown',
+                license: 'unknown',
+                digest: 'unknown'
+            };
+        });
+    }
+
     /**
      * Get benchmarks for a variant on specific hardware
      */

package/src/data/seed/README.md

@@ -0,0 +1,8 @@
+This directory contains the packaged Ollama model database snapshot used on
+first run.
+
+`models.db` is copied to `~/.llm-checker/models.db` only when the user does not
+already have a local database. After that, `llm-checker sync` updates the user's
+local copy.
+
+Refresh cadence: weekly via `.github/workflows/update-model-db.yml`.