llm-checker 3.5.12 → 3.5.13

package/bin/enhanced_cli.js

@@ -4,6 +4,7 @@ const chalk = require('chalk');
 const ora = require('ora');
 const { table } = require('table');
 const os = require('os');
+const readline = require('readline');
 const { spawn } = require('child_process');
 // LLMChecker is loaded lazily to avoid slow systeminformation init
 let _LLMChecker = null;
@@ -49,6 +50,7 @@ const {
     buildComplianceReport,
     serializeComplianceReport
 } = require('../src/policy/audit-reporter');
+const { estimateTokenSpeedFromHardware } = require('../src/utils/token-speed-estimator');
 const { renderCommandHeader, renderPersistentBanner } = require('../src/ui/cli-theme');
 const { launchInteractivePanel } = require('../src/ui/interactive-panel');
 const policyManager = new PolicyManager();
@@ -983,6 +985,12 @@ function displaySystemInfo(hardware, analysis) {
     const gpuColor = hardware.gpu.dedicated ? chalk.green : chalk.hex('#FFA500');
     const integratedList = formatGpuInventoryList(hardware.gpu.integratedGpuModels || hardware.summary?.integratedGpuModels);
     const dedicatedList = formatGpuInventoryList(hardware.gpu.dedicatedGpuModels || hardware.summary?.dedicatedGpuModels);
+    const integratedSharedMemory = hardware.gpu.sharedMemory || hardware.summary?.integratedSharedMemory || 0;
+    const vramDisplay = !hardware.gpu.dedicated && integratedSharedMemory > 0
+        ? `${integratedSharedMemory}GB shared`
+        : (hardware.gpu.vram === 0 && hardware.gpu.model && hardware.gpu.model.toLowerCase().includes('apple')
+            ? 'Unified Memory'
+            : `${hardware.gpu.vram || 'N/A'}GB`);
 
     const lines = [
         `${chalk.cyan('CPU:')} ${cpuColor(hardware.cpu.brand)} ${chalk.gray(`(${hardware.cpu.cores} cores, ${hardware.cpu.speed}GHz)`)}`,
@@ -990,7 +998,7 @@ function displaySystemInfo(hardware, analysis) {
         `${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('VRAM:')} ${vramDisplay}${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)}`,
     ];
@@ -1426,6 +1434,266 @@ function displayCalibratedRoutingDecision(commandName, calibratedPolicy, routeDe
     console.log(chalk.blue('╰'));
 }
 
+function parseAiRunModelSizeB(value) {
+    const match = String(value || '').match(/(\d+(?:\.\d+)?)\s*([kmb])\+?/i);
+    if (!match) return null;
+
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || amount <= 0) return null;
+
+    const unit = match[2].toLowerCase();
+    if (unit === 'b') return amount;
+    if (unit === 'm') return amount / 1000;
+    if (unit === 'k') return amount / 1_000_000;
+    return null;
+}
+
+function normalizeAiRunModelName(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/:latest$/, '');
+}
+
+function findAiRunLocalModel(localModels = [], modelName = '') {
+    const target = normalizeAiRunModelName(modelName);
+    if (!target) return null;
+
+    return localModels.find((model) => {
+        const name = normalizeAiRunModelName(model.name || model.model);
+        if (!name) return false;
+        return name === target || name.includes(target) || target.includes(name);
+    }) || null;
+}
+
+function resolveAiRunModelSizeB(modelName, aiSelector, localModel = null) {
+    const localParameterSize = localModel?.details?.parameter_size || localModel?.size;
+    const parsedLocalSize = parseAiRunModelSizeB(localParameterSize);
+    if (parsedLocalSize) return parsedLocalSize;
+
+    const parsedNameSize = parseAiRunModelSizeB(modelName);
+    if (parsedNameSize) return parsedNameSize;
+
+    if (aiSelector && typeof aiSelector.estimateModelSize === 'function') {
+        const selectorSize = Number(aiSelector.estimateModelSize(modelName));
+        if (Number.isFinite(selectorSize) && selectorSize > 0) return selectorSize;
+    }
+
+    return 7;
+}
+
+function formatAiRunNumber(value, decimals = 1) {
+    const number = Number(value);
+    if (!Number.isFinite(number)) return 'N/A';
+    return number.toFixed(decimals).replace(/\.0$/, '');
+}
+
+function estimateAiRunWorkingSetGB(modelSizeB, localModel = null) {
+    const fileSizeGB = Number(localModel?.fileSizeGB) || 0;
+    const parameterEstimateGB = (Number(modelSizeB) * 0.75) + 2;
+    if (fileSizeGB > 0) {
+        return Math.max(fileSizeGB * 1.15, parameterEstimateGB * 0.85);
+    }
+    return parameterEstimateGB;
+}
+
+function formatAiRunHardwareSummary(systemInfo = {}) {
+    const cpuBrand = systemInfo.cpu?.brand || systemInfo.cpu?.model || 'CPU';
+    const cores = systemInfo.cpu?.cores ? ` (${systemInfo.cpu.cores} cores)` : '';
+    const memory = systemInfo.memory?.total ? `${systemInfo.memory.total}GB RAM` : 'RAM unknown';
+    const gpu = systemInfo.gpu?.model || 'GPU not detected';
+    return `${cpuBrand}${cores}, ${memory}, ${gpu}`;
+}
+
+function formatAiRunMethod(method = '') {
+    return String(method || 'selector')
+        .replace(/[_-]+/g, ' ')
+        .replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+
+function formatAiRunReason(reason = '') {
+    const text = String(reason || '').replace(/\s+/g, ' ').trim();
+    if (!text) return 'Selected from local model compatibility scoring.';
+    return text.length > 120 ? `${text.slice(0, 117)}...` : text;
+}
+
+function formatAiRunMeasuredSpeed(benchmark = null) {
+    if (!benchmark) return null;
+    if (!benchmark.success) {
+        return `not available (${benchmark.error || 'benchmark failed'})`;
+    }
+
+    const parts = [];
+    if (Number(benchmark.evalTokensPerSecond) > 0) {
+        parts.push(`${formatAiRunNumber(benchmark.evalTokensPerSecond)} eval t/s`);
+    }
+    if (Number(benchmark.endToEndTokensPerSecond) > 0) {
+        parts.push(`${formatAiRunNumber(benchmark.endToEndTokensPerSecond)} end-to-end t/s`);
+    }
+    if (parts.length === 0 && Number(benchmark.tokensPerSecond) > 0) {
+        parts.push(`${formatAiRunNumber(benchmark.tokensPerSecond)} t/s`);
+    }
+
+    const generated = Number(benchmark.tokensGenerated) > 0
+        ? `, ${benchmark.tokensGenerated} tokens`
+        : '';
+    return `${parts.join(', ')}${generated}`;
+}
+
+function displayAiRunReference({ result, systemInfo, taskHint, candidateModels, localModels, aiSelector, benchmark }) {
+    const localModel = findAiRunLocalModel(localModels, result.bestModel);
+    const modelSizeB = resolveAiRunModelSizeB(result.bestModel, aiSelector, localModel);
+    const speedEstimate = estimateTokenSpeedFromHardware(systemInfo, {
+        modelSizeB,
+        modelName: result.bestModel
+    });
+    const workingSetGB = estimateAiRunWorkingSetGB(modelSizeB, localModel);
+    const localCount = result.localModelsCount || candidateModels.length;
+    const dbCount = result.totalModelsEvaluated;
+    const confidence = Number(result.confidence);
+    const confidenceText = Number.isFinite(confidence)
+        ? `${Math.round(confidence * 100)}%`
+        : 'N/A';
+    const idealModel = result.recommendedFromDatabase;
+    const usesFallback = idealModel && idealModel !== result.bestModel && result.isRecommendedInstalled === false;
+    const measuredSpeed = formatAiRunMeasuredSpeed(benchmark);
+
+    console.log('\n' + chalk.bold('AI Run reference'));
+    console.log(chalk.gray('----------------'));
+    console.log(`${chalk.gray('Task:')} ${chalk.white(taskHint || 'general')}`);
+    console.log(`${chalk.gray('Selected local model:')} ${chalk.green.bold(result.bestModel)}`);
+
+    if (idealModel) {
+        const idealStatus = usesFallback ? chalk.yellow('not installed') : chalk.green('available');
+        console.log(`${chalk.gray('Best database match:')} ${chalk.cyan(idealModel)} ${chalk.gray('(')}${idealStatus}${chalk.gray(')')}`);
+    }
+
+    console.log(`${chalk.gray('Why this model:')} ${formatAiRunReason(result.reasoning || result.reason)}`);
+    console.log(`${chalk.gray('Confidence:')} ${chalk.white(confidenceText)} ${chalk.gray(`via ${formatAiRunMethod(result.method)}`)}`);
+    console.log(`${chalk.gray('Models evaluated:')} ${chalk.white(`${localCount} local`)}${dbCount ? chalk.gray(`, ${dbCount} database`) : ''}`);
+    console.log(`${chalk.gray('Hardware:')} ${formatAiRunHardwareSummary(systemInfo)}`);
+    console.log(`${chalk.gray('Estimated speed:')} ${chalk.yellow(`~${speedEstimate.tokensPerSecond} tokens/sec`)} ${chalk.gray(`${speedEstimate.backend}, generation only`)}`);
+
+    if (measuredSpeed) {
+        const speedColor = benchmark?.success ? chalk.green : chalk.yellow;
+        console.log(`${chalk.gray('Measured speed:')} ${speedColor(measuredSpeed)}`);
+    }
+
+    console.log(`${chalk.gray('Memory reference:')} ${chalk.white(`~${formatAiRunNumber(modelSizeB)}B params, ~${formatAiRunNumber(workingSetGB)}GB working set`)}`);
+
+    if (usesFallback) {
+        console.log(`${chalk.gray('Install ideal model:')} ${chalk.cyan(`ollama pull ${idealModel}`)}`);
+    }
+}
+
+function formatAiRunTurnSpeed(result = {}) {
+    const evalSpeed = Number(result.evalTokensPerSecond);
+    const preferredSpeed = evalSpeed > 0 ? evalSpeed : Number(result.tokensPerSecond);
+
+    if (!Number.isFinite(preferredSpeed) || preferredSpeed <= 0) {
+        return '[speed unavailable]';
+    }
+
+    return `[${formatAiRunNumber(preferredSpeed)} tokens/sec]`;
+}
+
+async function runAiRunChatTurn(client, modelName, messages) {
+    let printed = false;
+    const result = await client.streamChat(
+        modelName,
+        messages,
+        {
+            keepAlive: '5m',
+            timeoutMs: 180000
+        },
+        (chunk) => {
+            printed = true;
+            process.stdout.write(chunk);
+        }
+    );
+
+    if (!printed && result.response) {
+        process.stdout.write(result.response);
+    }
+
+    const responseText = result.response || result.message?.content || '';
+    const needsSpace = responseText.length > 0 && !/\s$/.test(responseText);
+    process.stdout.write(`${needsSpace ? ' ' : ''}${chalk.gray(formatAiRunTurnSpeed(result))}\n\n`);
+
+    return result;
+}
+
+function askAiRunQuestion(rl, promptText) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const handleClose = () => {
+            if (!settled) {
+                settled = true;
+                resolve(null);
+            }
+        };
+
+        rl.once('close', handleClose);
+        rl.question(promptText, (answer) => {
+            if (settled) return;
+            settled = true;
+            rl.off('close', handleClose);
+            resolve(answer);
+        });
+    });
+}
+
+async function runAiRunInteractiveChat(client, modelName) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const messages = [];
+    let closed = false;
+
+    rl.on('SIGINT', () => {
+        process.stdout.write('\n');
+        rl.close();
+    });
+    rl.on('close', () => {
+        closed = true;
+    });
+
+    try {
+        while (!closed) {
+            const input = await askAiRunQuestion(rl, chalk.cyan('>>> '));
+            if (input === null) break;
+
+            const trimmed = String(input || '').trim();
+
+            if (!trimmed) {
+                continue;
+            }
+
+            if (['/bye', '/exit', '/quit', 'q'].includes(trimmed.toLowerCase())) {
+                break;
+            }
+
+            if (['/?', '/help'].includes(trimmed.toLowerCase())) {
+                console.log('Commands: /bye, /exit, /quit');
+                continue;
+            }
+
+            messages.push({ role: 'user', content: input });
+
+            try {
+                const response = await runAiRunChatTurn(client, modelName, messages);
+                const assistantContent = response.response || response.message?.content || '';
+                messages.push({ role: 'assistant', content: assistantContent });
+            } catch (error) {
+                console.error(chalk.red(`Chat request failed: ${error.message}`));
+            }
+        }
+    } finally {
+        rl.close();
+    }
+}
+
 function displayModelsStats(originalCount, filteredCount, options) {
     console.log('\n' + chalk.bgGreen.white.bold('  DATABASE STATS '));
     console.log(chalk.green('╭' + '─'.repeat(60)));
@@ -3204,7 +3472,7 @@ program
         const spinner = ora('Checking Ollama integration...').start();
 
         try {
-            const checker = new (getLLMChecker())();
+            const checker = new (getLLMChecker())({ verbose: false });
             const analysis = await checker.analyze();
 
             if (!analysis.ollamaInfo.available) {
@@ -3906,14 +4174,15 @@ program
     .option('--json', 'Output in JSON format')
     .action(async (options) => {
         if (!options.json) showAsciiArt('list-models');
-        const spinner = ora('📋 Loading models database...').start();
+        const spinner = options.json ? null : ora('📋 Loading models database...').start();
 
         try {
             const checker = new (getLLMChecker())();
-            const data = await checker.ollamaScraper.scrapeAllModels(false);
+            const data = await checker.loadOllamaModelData();
             
             if (!data || !data.models) {
-                spinner.fail('No models found in database');
+                if (spinner) spinner.fail('No models found in database');
+                else console.error('No models found in database');
                 return;
             }
 
@@ -4004,9 +4273,9 @@ program
                         return (b.pulls || 0) - (a.pulls || 0);
                     });
                     
-                    spinner.text = `Sorted by hardware compatibility (${getHardwareTierForDisplay(hardware)})`;
+                    if (spinner) spinner.text = `Sorted by hardware compatibility (${getHardwareTierForDisplay(hardware)})`;
                 } catch (error) {
-                    console.warn('Could not sort by hardware compatibility:', error.message);
+                    if (!options.json) console.warn('Could not sort by hardware compatibility:', error.message);
                     // Fallback a ordenar por popularidad
                     models.sort((a, b) => (b.pulls || 0) - (a.pulls || 0));
                 }
@@ -4019,7 +4288,7 @@ program
             const limit = parseInt(options.limit) || 50;
             const displayModels = models.slice(0, limit);
 
-            spinner.succeed(`✅ Found ${models.length} models (showing ${displayModels.length})`);
+            if (spinner) spinner.succeed(`✅ Found ${models.length} models (showing ${displayModels.length})`);
 
             if (options.json) {
                 console.log(JSON.stringify(displayModels, null, 2));
@@ -4042,7 +4311,7 @@ program
             }
 
         } catch (error) {
-            spinner.fail('Failed to load models');
+            if (spinner) spinner.fail('Failed to load models');
             console.error(chalk.red('Error:'), error.message);
             if (process.env.DEBUG) {
                 console.error(error.stack);
@@ -4143,6 +4412,8 @@ program
         '--calibrated [file]',
         'Enable calibrated routing policy (optional file path; defaults to ~/.llm-checker/calibration-policy.{yaml,yml,json})'
     )
+    .option('--benchmark', 'Run a short local speed test before launching')
+    .option('--reference-only', 'Show model choice and speed reference without launching Ollama')
     .action(async (options) => {
         showAsciiArt('ai-run');
         // Check if Ollama is installed first
@@ -4156,6 +4427,14 @@ program
             const aiSelector = new AIModelSelector();
             const checker = new (getLLMChecker())();
             const systemInfo = await checker.getSystemInfo();
+            let ollamaClient = null;
+            const getOllamaClient = () => {
+                if (!ollamaClient) {
+                    const OllamaClient = require('../src/ollama/client');
+                    ollamaClient = new OllamaClient();
+                }
+                return ollamaClient;
+            };
             const routingPreference = resolveRoutingPolicyPreference({
                 policyOption: options.policy,
                 calibratedOption: options.calibrated
@@ -4164,18 +4443,18 @@ program
             
             // Get available models or use provided ones
             let candidateModels = options.models;
+            let localModels = [];
             
             if (!candidateModels) {
-                spinner.text = '📋 Getting available Ollama models...';
-                const OllamaClient = require('../src/ollama/client');
-                const client = new OllamaClient();
+                spinner.text = 'Getting available Ollama models...';
+                const client = getOllamaClient();
                 
                 try {
-                    const models = await client.getLocalModels();
-                    candidateModels = models.map(m => m.name || m.model);
+                    localModels = await client.getLocalModels();
+                    candidateModels = localModels.map(m => m.name || m.model);
                     
                     if (candidateModels.length === 0) {
-                        spinner.fail('❌ No Ollama models found');
+                        spinner.fail('No Ollama models found');
                         console.log('\nInstall some models first:');
                         console.log('  ollama pull llama2:7b');
                         console.log('  ollama pull mistral:7b');
@@ -4183,7 +4462,7 @@ program
                         return;
                     }
                 } catch (error) {
-                    spinner.fail('❌ Failed to get Ollama models');
+                    spinner.fail('Failed to get Ollama models');
                     console.error(chalk.red('Error:'), error.message);
                     return;
                 }
@@ -4224,28 +4503,62 @@ program
                         )}) are not installed locally. Falling back to AI selector.`
                     );
                 }
-                result = await aiSelector.selectBestModel(candidateModels, systemSpecs, taskHint);
+                result = await aiSelector.selectBestModel(candidateModels, systemSpecs, taskHint, { silent: true });
             }
             
             spinner.succeed(`Selected ${chalk.green.bold(result.bestModel)} (${result.method}, ${Math.round(result.confidence * 100)}% confidence)`);
+
+            let benchmark = null;
+            if (options.benchmark) {
+                const benchmarkSpinner = ora(`Measuring local throughput for ${result.bestModel}...`).start();
+                try {
+                    benchmark = await getOllamaClient().testModelPerformance(
+                        result.bestModel,
+                        'Write one concise sentence about local LLM performance.'
+                    );
+
+                    if (benchmark.success) {
+                        benchmarkSpinner.succeed(`Measured ${formatAiRunNumber(benchmark.tokensPerSecond)} tokens/sec`);
+                    } else {
+                        benchmarkSpinner.stop();
+                        console.log(chalk.yellow(`Benchmark unavailable: ${benchmark.error || 'unknown error'}`));
+                    }
+                } catch (error) {
+                    benchmark = { success: false, error: error.message };
+                    benchmarkSpinner.stop();
+                    console.log(chalk.yellow(`Benchmark unavailable: ${error.message}`));
+                }
+            }
+
             displayCalibratedRoutingDecision('ai-run', calibratedPolicy, routeDecision, routingPreference.warnings);
+            displayAiRunReference({
+                result,
+                systemInfo,
+                taskHint,
+                candidateModels,
+                localModels,
+                aiSelector,
+                benchmark
+            });
+
+            if (options.referenceOnly) {
+                console.log(chalk.gray('\nReference-only mode: not launching Ollama.'));
+                return;
+            }
             
-            // Execute the selected model
-            console.log(chalk.magenta.bold(`\nLaunching ${result.bestModel}...`));
-            console.log(chalk.gray(`Tip: Type ${chalk.cyan('/bye')} to exit the chat when finished\n`));
-            
-            const args = ['run', result.bestModel];
             if (options.prompt) {
-                args.push(options.prompt);
+                console.log(chalk.cyan(`\n>>> ${options.prompt}`));
+                await runAiRunChatTurn(
+                    getOllamaClient(),
+                    result.bestModel,
+                    [{ role: 'user', content: options.prompt }]
+                );
+                return;
             }
-            
-            const ollamaProcess = spawn('ollama', args, { 
-                stdio: 'inherit'
-            });
-            
-            ollamaProcess.on('error', (error) => {
-                console.error(chalk.red('Failed to launch Ollama:'), error.message);
-            });
+
+            console.log(chalk.magenta.bold(`\nStarting chat with ${result.bestModel}...`));
+            console.log(chalk.gray(`Tip: Type ${chalk.cyan('/bye')} to exit the chat when finished\n`));
+            await runAiRunInteractiveChat(getOllamaClient(), result.bestModel);
             
         } catch (error) {
             console.error(chalk.red('❌ AI-powered execution failed:'), error.message);
@@ -5128,9 +5441,23 @@ program
 
                 if (backend === 'rocm' && info.info) {
                     console.log(`  ROCm: ${info.info.rocmVersion}`);
-                    console.log(`  Total VRAM: ${info.info.totalVRAM}GB`);
+                    const integratedOnly = (info.info.gpus || []).length > 0 &&
+                        (info.info.gpus || []).every((gpu) => gpu.type === 'integrated');
+                    if (integratedOnly) {
+                        console.log(`  Total dedicated aperture: ${info.info.totalVRAM || 0}GB`);
+                        console.log(`  Total shared memory: ${info.info.totalSharedMemory || 0}GB`);
+                    } else {
+                        console.log(`  Total VRAM: ${info.info.totalVRAM}GB`);
+                    }
                     for (const gpu of info.info.gpus) {
-                        console.log(`  ${gpu.name}: ${gpu.memory.total}GB`);
+                        if (gpu.type === 'integrated') {
+                            const dedicated = gpu.memory?.dedicated || 0;
+                            const shared = gpu.memory?.shared || gpu.memory?.total || 0;
+                            const dedicatedLabel = dedicated > 0 ? `, ${dedicated}GB aperture` : '';
+                            console.log(`  ${gpu.name}: ${shared}GB shared${dedicatedLabel} (Integrated)`);
+                        } else {
+                            console.log(`  ${gpu.name}: ${gpu.memory.total}GB`);
+                        }
                     }
                 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.12",
+  "version": "3.5.13",
   "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",
@@ -36,6 +36,7 @@
     "list-models": "node bin/enhanced_cli.js list-models",
     "ai-check": "node bin/enhanced_cli.js ai-check",
     "ai-run": "node bin/enhanced_cli.js ai-run",
+    "sync:seed": "node bin/enhanced_cli.js sync --force --quiet && node scripts/update-seed-db.js",
     "benchmark": "cd ml-model && python python/benchmark_collector.py",
     "train-ai": "cd ml-model && python python/train_model.py",
     "postinstall": "echo 'LLM Checker installed. Run: llm-checker hw-detect'"

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;