llm-checker 3.5.12 → 3.5.13

package/src/hardware/unified-detector.js

@@ -307,7 +307,10 @@ class UnifiedDetector {
         summary.dedicatedGpuCount = topology.dedicatedCount;
         summary.integratedGpuModels = topology.integratedModels;
         summary.dedicatedGpuModels = topology.dedicatedModels;
-        summary.integratedSharedMemory = topology.integratedSharedMemory;
+        summary.integratedSharedMemory = Math.max(
+            topology.integratedSharedMemory,
+            this.getPrimaryIntegratedSharedMemory(primary)
+        );
         if (!summary.gpuModel) {
             summary.gpuModel = topology.primaryModel || null;
         }
@@ -324,9 +327,17 @@ class UnifiedDetector {
         summary.runtimeBackendName = runtimeSelection.name;
         summary.hasRuntimeAssist = runtimeSelection.assisted;
 
-        // Effective memory for LLM loading
-        // For GPU: use VRAM; for CPU/Metal: use system RAM
-        if (summary.totalVRAM > 0 && ['cuda', 'rocm', 'intel'].includes(primary?.type)) {
+        // Effective memory for LLM loading. Integrated ROCm/iGPU devices expose
+        // a small aperture as VRAM and a much larger shared pool for model-fit
+        // decisions, so avoid treating the aperture as dedicated VRAM.
+        if (
+            ['rocm', 'intel'].includes(primary?.type) &&
+            summary.hasIntegratedGPU &&
+            !summary.hasDedicatedGPU &&
+            summary.integratedSharedMemory > 0
+        ) {
+            summary.effectiveMemory = summary.integratedSharedMemory;
+        } else if (summary.totalVRAM > 0 && ['cuda', 'rocm', 'intel'].includes(primary?.type)) {
             summary.effectiveMemory = summary.totalVRAM;
         } else {
             // Use 70% of system RAM for models (leave room for OS)
@@ -339,6 +350,21 @@ class UnifiedDetector {
         return summary;
     }
 
+    getPrimaryIntegratedSharedMemory(primary) {
+        const gpus = Array.isArray(primary?.info?.gpus) ? primary.info.gpus : [];
+        return gpus
+            .filter((gpu) => gpu?.type === 'integrated')
+            .reduce((max, gpu) => {
+                const candidates = [
+                    gpu?.sharedMemory,
+                    gpu?.unifiedMemory,
+                    gpu?.memory?.shared,
+                    gpu?.memory?.total
+                ].map(Number).filter((value) => Number.isFinite(value) && value > 0);
+                return Math.max(max, ...candidates, 0);
+            }, 0);
+    }
+
     classifyHardwareTierFromSummary(summary = {}) {
         const effectiveMem = Number(summary.effectiveMemory) || 0;
         const speed = Number(summary.speedCoefficient) || 0;
@@ -848,7 +874,11 @@ class UnifiedDetector {
         const summary = result.summary;
 
         // Leave headroom (2GB for GPU, 20% for RAM)
-        if (summary.bestBackend === 'cpu' || summary.bestBackend === 'metal') {
+        if (
+            summary.bestBackend === 'cpu' ||
+            summary.bestBackend === 'metal' ||
+            (summary.hasIntegratedGPU && !summary.hasDedicatedGPU && summary.integratedSharedMemory > 0)
+        ) {
             return sizeGB <= (summary.effectiveMemory - 2);
         } else {
             const availableVRAM = useMultiGPU ? summary.totalVRAM : (summary.totalVRAM / summary.gpuCount);
@@ -939,6 +969,10 @@ class UnifiedDetector {
             const gpuDesc = summary.gpuInventory || (
                 summary.isMultiGPU ? `${summary.gpuCount}x ${summary.gpuModel}` : summary.gpuModel
             );
+            if (summary.hasIntegratedGPU && !summary.hasDedicatedGPU && summary.integratedSharedMemory > 0) {
+                const dedicatedLabel = summary.totalVRAM > 0 ? `, ${summary.totalVRAM}GB aperture` : '';
+                return `${gpuDesc} (${summary.integratedSharedMemory}GB shared memory${dedicatedLabel}) + ${summary.cpuModel}`;
+            }
             return `${gpuDesc} (${summary.totalVRAM}GB VRAM) + ${summary.cpuModel}`;
         }
         else if (summary.bestBackend === 'metal') {

package/src/index.js

@@ -78,7 +78,6 @@ class LLMChecker {
             // Report hardware detection progress before platform-specific analysis
             if (this.progress) {
                 this.progress.substep(`CPU detected: ${hardware.cpu.brand} (${hardware.cpu.cores} cores)`);
-                await new Promise(resolve => setTimeout(resolve, 200)); // Small delay for demo
                 const isApple = detectedPlatform === 'darwin';
                 const memLabel = isApple ? 'unified memory' : 'RAM';
                 this.progress.substep(`Memory detected: ${hardware.memory.total}GB ${memLabel}`, true);
@@ -117,7 +116,6 @@ class LLMChecker {
         // Apple Silicon optimized analysis with unified memory consideration
         if (this.progress) {
             this.progress.substep(`CPU detected: ${hardware.cpu.brand} (${hardware.cpu.cores} cores)`);
-            await new Promise(resolve => setTimeout(resolve, 200));
             this.progress.substep(`Memory detected: ${hardware.memory.total}GB unified memory`, true);
             const summary = `${hardware.cpu.brand}, ${hardware.memory.total}GB RAM, ${hardware.gpu.model || 'Apple Silicon GPU'}`;
             this.progress.stepComplete(summary);
@@ -131,7 +129,6 @@ class LLMChecker {
         // Windows-specific analysis with discrete GPU / iGPU handling
         if (this.progress) {
             this.progress.substep(`CPU detected: ${hardware.cpu.brand} (${hardware.cpu.cores} cores)`);
-            await new Promise(resolve => setTimeout(resolve, 200));
             this.progress.substep(`Memory detected: ${hardware.memory.total}GB RAM`, true);
             const summary = `${hardware.cpu.brand}, ${hardware.memory.total}GB RAM, ${hardware.gpu.model || 'Integrated GPU'}`;
             this.progress.stepComplete(summary);
@@ -145,7 +142,6 @@ class LLMChecker {
         // Linux-specific analysis (similar to Windows but with Linux considerations)
         if (this.progress) {
             this.progress.substep(`CPU detected: ${hardware.cpu.brand} (${hardware.cpu.cores} cores)`);
-            await new Promise(resolve => setTimeout(resolve, 200));
             this.progress.substep(`Memory detected: ${hardware.memory.total}GB RAM`, true);
             const summary = `${hardware.cpu.brand}, ${hardware.memory.total}GB RAM, ${hardware.gpu.model || 'GPU'}`;
             this.progress.stepComplete(summary);
@@ -516,7 +512,7 @@ class LLMChecker {
         
         try {
             // 1. Obtener TODOS los modelos de la base de datos de Ollama
-            const ollamaData = await this.ollamaScraper.scrapeAllModels(false);
+            const ollamaData = await this.loadOllamaModelData();
             const allOllamaModels = ollamaData.models || [];
             this.logger.info(`Found ${allOllamaModels.length} models in Ollama database`);
 
@@ -2430,14 +2426,51 @@ class LLMChecker {
             this.getAllModels().find(m => m.name.toLowerCase().includes(name.toLowerCase()));
     }
 
+    async loadSyncedOllamaModelData() {
+        const ModelDatabase = require('./data/model-database');
+        const database = new ModelDatabase();
+
+        try {
+            await database.initialize();
+            const models = database.getAllModelsWithVariants();
+            const stats = database.getStats();
+
+            if (models.length > 0) {
+                return {
+                    models,
+                    total_count: models.length,
+                    cached_at: stats.lastSync || null,
+                    source: 'ollama_sqlite_database'
+                };
+            }
+        } finally {
+            database.close();
+        }
+
+        return null;
+    }
+
+    async loadOllamaModelData() {
+        try {
+            const syncedData = await this.loadSyncedOllamaModelData();
+            if (syncedData?.models?.length > 0) {
+                return syncedData;
+            }
+        } catch (error) {
+            this.logger.warn('Synced SQLite model database unavailable, falling back to Ollama cache', { error: error.message });
+        }
+
+        return this.ollamaScraper.scrapeAllModels(false);
+    }
+
 
     async generateIntelligentRecommendations(hardware, options = {}) {
         try {
             this.logger.info('Generating intelligent recommendations...');
             const selectedRuntime = normalizeRuntime(options.runtime || 'ollama');
             
-            // Obtener todos los modelos de Ollama
-            const ollamaData = await this.ollamaScraper.scrapeAllModels(false);
+            // Prefer the synced SQLite catalog so `llm-checker sync` updates recommendations immediately.
+            const ollamaData = await this.loadOllamaModelData();
             const allModels = ollamaData.models || [];
 
             if (allModels.length === 0) {

package/src/models/ai-check-selector.js

@@ -77,8 +77,8 @@ Respond with JSON only, no additional text.`;
         // Phase 1: Get ALL available models from the 177-model Ollama database
         const hardware = await this.deterministicSelector.getHardware();
         
-        // Use the same large database that check command uses (177 models)
-        const ollamaData = await this.ollamaScraper.scrapeAllModels(false);
+        // Use the same synced database that recommend/check use.
+        const ollamaData = await this.loadModelDatabase();
         const allOllamaModels = ollamaData.models || [];
         
         if (!silent) {
@@ -248,6 +248,31 @@ Respond with JSON only, no additional text.`;
         };
     }
 
+    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.
+        }
+
+        return this.ollamaScraper.scrapeAllModels(false);
+    }
+
     /**
      * Pick the best installed evaluator model
      */

package/src/models/deterministic-selector.js

@@ -44,11 +44,16 @@ class DeterministicModelSelector {
         this.familyBumps = {
             'qwen2.5': 2,
             'qwen3': 4,
+            'gemma3': 3,
             'deepseek': 3,
+            'deepseek-r1': 5,
+            'deepseek-coder': 4,
             'mistral': 1,
             'llama3.1': 1,
             'llama3.2': 2,
             'gemma2': 1,
+            'yi': -3,
+            'yi-coder': 1,
             'phi-3': 0,
             'granite': 0,
             'solar': 0,
@@ -750,7 +755,13 @@ class DeterministicModelSelector {
         if (ollamaModel.primary_category === 'reasoning') derivedTags.add('reasoning');
         if (ollamaModel.primary_category === 'creative') derivedTags.add('creative');
 
-        return variants.map((variant) => {
+        const hasConcreteVariants = variants.some((variant) => this.variantHasConcreteSizeOrParams(variant));
+        const selectableVariants = hasConcreteVariants
+            ? variants.filter((variant) => this.variantHasConcreteSizeOrParams(variant))
+            : variants;
+
+        return selectableVariants
+            .map((variant) => {
             const variantTag = variant.tag || fallbackTag;
             const quant = this.resolveVariantQuantization(variant, variantTag);
             const paramsB = this.resolveVariantParamsB(ollamaModel, variant, quant);
@@ -821,6 +832,8 @@ class DeterministicModelSelector {
                 modalities,
                 tags: modelTags,
                 model_identifier: variantTag,
+                last_updated: ollamaModel.last_updated || ollamaModel.lastUpdated || '',
+                updated_at: ollamaModel.updated_at || ollamaModel.updatedAt || '',
                 installed: false,
                 pulls: ollamaModel.actual_pulls || ollamaModel.pulls || 0,
                 availableQuantizations,
@@ -842,6 +855,28 @@ class DeterministicModelSelector {
         });
     }
 
+    variantHasConcreteSizeOrParams(variant = {}) {
+        const params = this.extractParamsFromString(
+            variant.params_b,
+            variant.paramsB,
+            variant.parameter_size,
+            variant.size,
+            variant.tag,
+            variant.label,
+            variant.name
+        );
+        if (Number.isFinite(params) && params > 0) return true;
+
+        const artifactSize = Number(
+            variant.real_size_gb ??
+            variant.estimated_size_gb ??
+            variant.size_gb ??
+            NaN
+        );
+
+        return Number.isFinite(artifactSize) && artifactSize > 0;
+    }
+
     parseBillionsValue(rawValue) {
         return parseMoEBillionsValue(rawValue);
     }
@@ -861,7 +896,26 @@ class DeterministicModelSelector {
 
     parseDateSafe(value) {
         if (!value || typeof value !== 'string') return null;
-        const parsed = new Date(value);
+        const normalized = value.trim();
+        const relativeMatch = normalized.match(/^(\d+)\s*(minutes?|hours?|days?|weeks?|months?|years?)\s+ago$/i);
+        if (relativeMatch) {
+            const amount = parseInt(relativeMatch[1], 10);
+            const unit = relativeMatch[2].toLowerCase();
+            const days =
+                unit.startsWith('minute') ? amount / (24 * 60) :
+                unit.startsWith('hour') ? amount / 24 :
+                unit.startsWith('day') ? amount :
+                unit.startsWith('week') ? amount * 7 :
+                unit.startsWith('month') ? amount * 30 :
+                unit.startsWith('year') ? amount * 365 :
+                null;
+
+            if (Number.isFinite(days)) {
+                return new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+            }
+        }
+
+        const parsed = new Date(normalized);
         if (Number.isNaN(parsed.getTime())) return null;
         return parsed;
     }
@@ -912,8 +966,7 @@ class DeterministicModelSelector {
             model.updatedAt,
             model.release_date,
             model.released_at,
-            model.created_at,
-            model.detailed_scraped_at
+            model.created_at
         ];
 
         const updatedAt = dateCandidates
@@ -1027,6 +1080,9 @@ class DeterministicModelSelector {
 
             const regex = /(\d+\.?\d*)\s*([BbMm])/g;
             for (const match of value.matchAll(regex)) {
+                const suffix = value.slice(match.index + match[0].length, match.index + match[0].length + 2);
+                if (/^\s*b\b/i.test(suffix) || /^\s*[gk]b\b/i.test(suffix)) continue;
+
                 const amount = parseFloat(match[1]);
                 const unit = match[2].toUpperCase();
                 pushCandidate(unit === 'M' ? amount / 1000 : amount);
@@ -1103,7 +1159,7 @@ class DeterministicModelSelector {
             ollamaModel.parameter_count
         );
         if (metadataCandidates.length > 0) {
-            return Math.max(...metadataCandidates);
+            return metadataCandidates[0];
         }
 
         const artifactSizeGB = this.extractVariantSizeGB(variant, null);
@@ -1136,7 +1192,7 @@ class DeterministicModelSelector {
     }
 
     extractVariantSizeGB(variant, paramsB) {
-        const candidate = Number(variant.real_size_gb ?? variant.estimated_size_gb ?? NaN);
+        const candidate = Number(variant.real_size_gb ?? variant.estimated_size_gb ?? variant.size_gb ?? NaN);
         if (Number.isFinite(candidate) && candidate > 0) return candidate;
         if (!Number.isFinite(paramsB) || paramsB <= 0) return 0.5;
         return Math.max(0.5, Math.round((paramsB * 0.58 + 0.5) * 10) / 10);
@@ -1207,11 +1263,14 @@ class DeterministicModelSelector {
         if (name.includes('qwen2.5')) return 'qwen2.5';
         if (name.includes('qwen3')) return 'qwen3';
         if (name.includes('qwen')) return 'qwen2.5';
+        if (name.includes('deepseek-r1')) return 'deepseek-r1';
+        if (name.includes('deepseek-coder')) return 'deepseek-coder';
         if (name.includes('deepseek')) return 'deepseek';
         if (name.includes('llama3.2') || name.includes('llama3.3')) return 'llama3.2';
         if (name.includes('llama3.1')) return 'llama3.1';
         if (name.includes('llama')) return 'llama';
         if (name.includes('mistral')) return 'mistral';
+        if (name.includes('gemma3')) return 'gemma3';
         if (name.includes('gemma')) return 'gemma2';
         if (name.includes('phi')) return 'phi-3';
         if (name.includes('llava')) return 'llava';
@@ -1219,6 +1278,8 @@ class DeterministicModelSelector {
         if (name.includes('solar')) return 'solar';
         if (name.includes('starcoder')) return 'starcoder';
         if (name.includes('minicpm')) return 'minicpm';
+        if (name.includes('yi-coder')) return 'yi-coder';
+        if (name.includes('yi')) return 'yi';
         return 'unknown';
     }
 
@@ -1351,7 +1412,9 @@ class DeterministicModelSelector {
         const hardware = this.normalizeHardwareProfile(detectedHardware);
         const installed = Array.isArray(installedModels) ? installedModels : await this.getInstalledModels();
         const externalPool = Array.isArray(modelPool) && modelPool.length > 0
-            ? this.normalizeExternalModels(modelPool)
+            ? (modelPool.some(model => typeof model?.paramsB === 'number' && model?.model_identifier)
+                ? modelPool
+                : this.normalizeExternalModels(modelPool))
             : await this.loadModelPool();
         
         if (!silent) {
@@ -1445,6 +1508,10 @@ class DeterministicModelSelector {
 
     filterByCategory(models, category) {
         return models.filter(model => {
+            if (this.isCloudVariantTag(model.model_identifier || model.name)) {
+                return false;
+            }
+
             switch (category) {
                 case 'coding':
                     return model.tags.some(tag => ['coder', 'code', 'instruct'].includes(tag)) ||
@@ -1682,6 +1749,12 @@ class DeterministicModelSelector {
         // Freshness/deprecation adjustment
         const freshnessAdjustment = this.calculateFreshnessAdjustment(model);
         Q += freshnessAdjustment;
+
+        const pulls = Number(model.pulls || model.actual_pulls || 0);
+        if (pulls >= 100000000) Q += 4;
+        else if (pulls >= 20000000) Q += 3;
+        else if (pulls >= 5000000) Q += 2;
+        else if (pulls >= 1000000) Q += 1;
         
         // Task alignment bump
         const taskBump = this.getTaskAlignmentBump(model, category);

package/src/ollama/client.js

@@ -668,6 +668,127 @@ class OllamaClient {
             throw new Error(`Failed to run chat request: ${error.message}`);
         }
     }
+
+    async streamChat(modelName, messages, options = {}, onChunk = null) {
+        const availability = await this.checkOllamaAvailability();
+        if (!availability.available) {
+            throw new Error(`Ollama not available: ${availability.error}`);
+        }
+
+        const {
+            tools,
+            format,
+            keepAlive,
+            timeoutMs = 120000,
+            generationOptions = {}
+        } = options;
+
+        const payload = {
+            model: modelName,
+            messages: Array.isArray(messages) ? messages : [],
+            stream: true
+        };
+
+        if (Array.isArray(tools) && tools.length > 0) payload.tools = tools;
+        if (format) payload.format = format;
+        if (keepAlive) payload.keep_alive = keepAlive;
+        if (generationOptions && Object.keys(generationOptions).length > 0) {
+            payload.options = generationOptions;
+        }
+
+        const startTime = Date.now();
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+        try {
+            const response = await fetch(`${this.baseURL}/api/chat`, {
+                method: 'POST',
+                signal: controller.signal,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
+            }
+
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let content = '';
+            let finalData = null;
+
+            const handleLine = (line) => {
+                if (!line.trim()) return;
+
+                const data = JSON.parse(line);
+                const chunk = data?.message?.content || '';
+                if (chunk) {
+                    content += chunk;
+                    if (typeof onChunk === 'function') {
+                        onChunk(chunk, data);
+                    }
+                }
+
+                if (data.done) {
+                    finalData = data;
+                }
+            };
+
+            if (response.body && typeof response.body.getReader === 'function') {
+                const reader = response.body.getReader();
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) break;
+
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+
+                    for (const line of lines) {
+                        handleLine(line);
+                    }
+                }
+            } else if (response.body && typeof response.body[Symbol.asyncIterator] === 'function') {
+                for await (const value of response.body) {
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+
+                    for (const line of lines) {
+                        handleLine(line);
+                    }
+                }
+            } else {
+                throw new Error('Streaming response body is not readable');
+            }
+
+            buffer += decoder.decode();
+            if (buffer.trim()) {
+                handleLine(buffer);
+            }
+
+            const responseTime = Date.now() - startTime;
+            const speed = this.calculateTokensPerSecond(finalData || {}, responseTime);
+
+            return {
+                ...(finalData || {}),
+                message: {
+                    role: 'assistant',
+                    content
+                },
+                response: content,
+                responseTime,
+                tokensPerSecond: speed.tokensPerSecond,
+                evalTokensPerSecond: speed.evalTokensPerSecond,
+                endToEndTokensPerSecond: speed.endToEndTokensPerSecond
+            };
+        } catch (error) {
+            throw new Error(`Failed to run streaming chat request: ${error.message}`);
+        } finally {
+            clearTimeout(timeoutId);
+        }
+    }
 }
 
 module.exports = OllamaClient;

package/src/ollama/enhanced-scraper.js

@@ -143,7 +143,8 @@ class EnhancedOllamaScraper {
                 seen.add(id);
 
                 // Try to extract pulls
-                const pullsMatch = match[0].match(/(\d+(?:\.\d+)?[KMB]?)\s*(?:Pulls|pulls)/i);
+                const cardText = this.cleanText(match[0]);
+                const pullsMatch = cardText.match(/(\d+(?:\.\d+)?\s*[KMB]?)\s*(?:Pulls|Downloads)/i);
                 const pulls = pullsMatch ? this.parsePulls(pullsMatch[1]) : 0;
 
                 models.push({ id, pulls });
@@ -160,13 +161,29 @@ class EnhancedOllamaScraper {
      */
     parsePulls(pullStr) {
         if (!pullStr) return 0;
-        const num = parseFloat(pullStr);
-        if (pullStr.includes('B')) return Math.round(num * 1e9);
-        if (pullStr.includes('M')) return Math.round(num * 1e6);
-        if (pullStr.includes('K')) return Math.round(num * 1e3);
+        const normalized = String(pullStr).replace(/\s+/g, '');
+        const num = parseFloat(normalized);
+        if (normalized.includes('B')) return Math.round(num * 1e9);
+        if (normalized.includes('M')) return Math.round(num * 1e6);
+        if (normalized.includes('K')) return Math.round(num * 1e3);
         return Math.round(num);
     }
 
+    cleanText(html = '') {
+        return String(html || '')
+            .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+            .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+            .replace(/<[^>]+>/g, ' ')
+            .replace(/&nbsp;|&#160;/g, ' ')
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#x27;|&#39;/g, "'")
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+
     /**
      * Scrape model detail page
      */
@@ -296,24 +313,12 @@ class EnhancedOllamaScraper {
      * Extract parameter count from tag
      */
     extractParams(tag) {
-        // Match patterns like: 8b, 70b, 7b, 1.5b, 0.5b, 405b
-        const match = tag.match(/(\d+\.?\d*)[bB](?:[^a-zA-Z]|$)/);
+        // Match patterns like: 8b, 70b, 1.5b, 335m, 22m
+        const match = tag.match(/(\d+\.?\d*)\s*([bBmM])(?:[^a-zA-Z]|$)/);
         if (match) {
-            return parseFloat(match[1]);
-        }
-
-        // Check for known sizes in model names
-        const sizePatterns = [
-            { pattern: /mini/i, size: 3.8 },
-            { pattern: /tiny/i, size: 1.1 },
-            { pattern: /small/i, size: 7 },
-            { pattern: /medium/i, size: 13 },
-            { pattern: /large/i, size: 34 },
-            { pattern: /xl/i, size: 70 },
-        ];
-
-        for (const { pattern, size } of sizePatterns) {
-            if (pattern.test(tag)) return size;
+            const value = parseFloat(match[1]);
+            const unit = match[2].toLowerCase();
+            return unit === 'm' ? value / 1000 : value;
         }
 
         return null;
@@ -329,9 +334,11 @@ class EnhancedOllamaScraper {
             { pattern: /q6[_-]?k/i, quant: 'Q6_K' },
             { pattern: /q5[_-]?k[_-]?m/i, quant: 'Q5_K_M' },
             { pattern: /q5[_-]?k[_-]?s/i, quant: 'Q5_K_S' },
+            { pattern: /q5[_-]?1/i, quant: 'Q5_K_M' },
             { pattern: /q5[_-]?0/i, quant: 'Q5_0' },
             { pattern: /q4[_-]?k[_-]?m/i, quant: 'Q4_K_M' },
             { pattern: /q4[_-]?k[_-]?s/i, quant: 'Q4_K_S' },
+            { pattern: /q4[_-]?1/i, quant: 'Q4_K_M' },
             { pattern: /q4[_-]?0/i, quant: 'Q4_0' },
             { pattern: /q3[_-]?k[_-]?m/i, quant: 'Q3_K_M' },
             { pattern: /q3[_-]?k[_-]?s/i, quant: 'Q3_K_S' },
@@ -468,7 +475,10 @@ class EnhancedOllamaScraper {
         // Try to get display name from title or h1
         const titleMatch = html.match(/<title>([^<]+)<\/title>/i);
         if (titleMatch) {
-            const title = titleMatch[1].split('·')[0].split('-')[0].trim();
+            const title = this.cleanText(titleMatch[1])
+                .split('·')[0]
+                .replace(/\s+-\s+Ollama.*$/i, '')
+                .trim();
             if (title && title.toLowerCase() !== 'ollama') {
                 return title;
             }
@@ -500,12 +510,15 @@ class EnhancedOllamaScraper {
     }
 
     extractPulls(html) {
-        const match = html.match(/(\d+(?:\.\d+)?[KMB]?)\s*(?:Pulls|pulls|Downloads|downloads)/i);
+        const text = this.cleanText(html);
+        const match = text.match(/(\d+(?:\.\d+)?\s*[KMB]?)\s*(?:Pulls|Downloads)\b/i);
         return match ? this.parsePulls(match[1]) : 0;
     }
 
     extractTagsCount(html) {
-        const match = html.match(/(\d+)\s*(?:Tags|tags|Versions|versions)/i);
+        const text = this.cleanText(html);
+        const match = text.match(/\bName\s+(\d+)\s+models?\s+Size\b/i) ||
+            text.match(/\b(\d+)\s+(?:Tags|Versions|models?)\b/i);
         return match ? parseInt(match[1]) : 1;
     }
 
@@ -534,7 +547,8 @@ class EnhancedOllamaScraper {
     }
 
     extractLastUpdated(html) {
-        const match = html.match(/Updated?\s*(\d+\s*(?:days?|weeks?|months?|hours?)\s*ago)/i);
+        const text = this.cleanText(html);
+        const match = text.match(/Updated\s+(\d+\s*(?:minutes?|hours?|days?|weeks?|months?|years?)\s+ago)/i);
         return match ? match[1] : '';
     }