llm-checker 3.1.0

package/src/ollama/.cache/README.md

@@ -0,0 +1,33 @@
+# Ollama Models Cache - STATIC DATABASE
+
+## ⚠️ IMPORTANT: Static Database with Pre-Classified Categories
+
+This directory contains a **static, pre-loaded database** of 177 Ollama models with complete category classifications.
+
+### Current Status:
+- **177 models** with real size data from Ollama Hub
+- **Pre-classified categories**: coding, creative, reasoning, multimodal, embeddings, chat, safety, general
+- **No automatic updates** - this is intentionally static for stability
+
+### If You Need to Update the Database in the Future:
+
+1. **Run database update process** (re-enable update functionality)
+2. **🚨 CRITICAL: RE-ADD CATEGORIES** after update:
+   - Run `node src/utils/model-classifier.js` on all new models
+   - Apply classification rules to new entries
+   - Update cache with category data
+3. **Test all use-case filters**:
+   - `--use-case coding`
+   - `--use-case creative` 
+   - `--use-case reasoning`
+   - `--use-case multimodal`
+   - `--use-case embeddings`
+   - `--use-case talking`
+4. **Verify category detection** works for all 7 use cases
+
+### Files:
+- `ollama-detailed-models.json` - Main cache with 177 models + categories
+- `README.md` - This documentation
+
+---
+**Note**: The database update functionality was intentionally removed to maintain stability and keep the current categorization system intact.

package/src/ollama/CLAUDE.md

@@ -0,0 +1,24 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+### Feb 12, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #3500 | 10:26 PM | 🔴 | pullModel() Stream Handling Improved - Success Validation Added | ~458 |
+| #3499 | " | 🔴 | Race Condition Fixed in Ollama Availability Cache | ~440 |
+| #3498 | 10:25 PM | 🔵 | testModelPerformance() Timeout Already Fixed | ~418 |
+| #3497 | " | 🔴 | Timeout Fixed in deleteModel() Using AbortController | ~391 |
+| #3496 | " | 🔴 | Timeout Fixed in testConnection() Using AbortController | ~395 |
+| #3495 | " | 🔴 | Fixed unbounded memory growth in native scraper HTTP request handler | ~361 |
+| #3493 | " | 🔴 | Fixed race condition in checkOllamaAvailability() with promise deduplication | ~398 |
+| #3491 | 10:24 PM | 🔴 | Added missing clearTimeout() in testModelPerformance() | ~319 |
+| #3489 | " | 🔴 | Fixed node-fetch timeout handling in testModelPerformance() | ~332 |
+| #3488 | " | 🔴 | Fixed node-fetch timeout handling in testConnection() tags check | ~303 |
+| #3486 | " | 🔴 | Fixed node-fetch timeout handling in getRunningModels() | ~308 |
+| #3484 | 10:23 PM | 🔵 | Ollama Client Timeout Implementation - Mixed Patterns with AbortController | ~554 |
+| #3443 | 9:59 PM | 🔵 | Ollama Native Scraper - Web Scraping with Dual Cache Strategy | ~594 |
+| #3437 | 9:58 PM | 🔵 | Ollama Client Implementation - HTTP API Wrapper with Connection Management | ~605 |
+</claude-mem-context>

package/src/ollama/client.js

@@ -0,0 +1,438 @@
+const fetch = require('node-fetch');
+
+class OllamaClient {
+    constructor(baseURL = null) {
+        // Support OLLAMA_HOST environment variable (standard Ollama configuration)
+        // Also support OLLAMA_URL for backwards compatibility
+        this.baseURL = baseURL || process.env.OLLAMA_HOST || process.env.OLLAMA_URL || 'http://localhost:11434';
+
+        // Normalize URL: ensure it has protocol and remove trailing slash
+        if (!this.baseURL.startsWith('http://') && !this.baseURL.startsWith('https://')) {
+            this.baseURL = 'http://' + this.baseURL;
+        }
+        this.baseURL = this.baseURL.replace(/\/$/, '');
+
+        this.isAvailable = null;
+        this.lastCheck = 0;
+        this.cacheTimeout = 30000;
+        this._pendingCheck = null;
+    }
+
+    async checkOllamaAvailability() {
+
+        if (this.isAvailable !== null && Date.now() - this.lastCheck < this.cacheTimeout) {
+            return this.isAvailable;
+        }
+
+        // Prevent concurrent requests — reuse in-flight promise
+        if (this._pendingCheck) {
+            return this._pendingCheck;
+        }
+
+        this._pendingCheck = this._doAvailabilityCheck();
+        try {
+            return await this._pendingCheck;
+        } finally {
+            this._pendingCheck = null;
+        }
+    }
+
+    async _doAvailabilityCheck() {
+
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
+            
+            const response = await fetch(`${this.baseURL}/api/version`, {
+                signal: controller.signal,
+                headers: { 'Content-Type': 'application/json' }
+            });
+            
+            clearTimeout(timeoutId);
+
+            if (response.ok) {
+                const data = await response.json();
+                this.isAvailable = { available: true, version: data.version || 'unknown' };
+                this.lastCheck = Date.now();
+                return this.isAvailable;
+            }
+
+            this.isAvailable = { available: false, error: 'Ollama not responding properly' };
+            this.lastCheck = Date.now();
+            return this.isAvailable;
+        } catch (error) {
+            let errorMessage;
+            let hint = '';
+
+            if (error.message.includes('ECONNREFUSED')) {
+                errorMessage = `Ollama not running at ${this.baseURL}`;
+                hint = 'Make sure Ollama is running. Try: ollama serve';
+            } else if (error.message.includes('timeout') || error.name === 'AbortError') {
+                errorMessage = `Ollama connection timeout at ${this.baseURL}`;
+                hint = 'The server is not responding. Check if Ollama is running and accessible.';
+            } else if (error.message.includes('ENOTFOUND')) {
+                errorMessage = `Cannot resolve host: ${this.baseURL}`;
+                hint = 'Check your OLLAMA_HOST environment variable or network configuration.';
+            } else {
+                errorMessage = error.message;
+            }
+
+            this.isAvailable = {
+                available: false,
+                error: errorMessage,
+                hint: hint,
+                attemptedURL: this.baseURL
+            };
+            this.lastCheck = Date.now();
+            return this.isAvailable;
+        }
+    }
+
+    async getLocalModels() {
+        const availability = await this.checkOllamaAvailability();
+        if (!availability.available) {
+            throw new Error(`Ollama not available: ${availability.error}`);
+        }
+
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 15000);
+            
+            const response = await fetch(`${this.baseURL}/api/tags`, {
+                signal: controller.signal,
+                headers: { 
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json'
+                }
+            });
+            
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
+            }
+
+            const data = await response.json();
+
+            if (!data.models) {
+                return [];
+            }
+
+            const models = data.models.map(model => this.parseOllamaModel(model));
+            return models;
+        } catch (error) {
+            throw new Error(`Failed to fetch local models: ${error.message}`);
+        }
+    }
+
+    async getRunningModels() {
+        const availability = await this.checkOllamaAvailability();
+        if (!availability.available) {
+            return [];
+        }
+
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10000);
+
+            const response = await fetch(`${this.baseURL}/api/ps`, {
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json'
+                }
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                return [];
+            }
+
+            const data = await response.json();
+
+            const runningModels = (data.models || []).map(model => ({
+                name: model.name,
+                model: model.model,
+                size: model.size,
+                digest: model.digest,
+                expires_at: model.expires_at,
+                size_vram: model.size_vram,
+                processor: model.processor || 'unknown'
+            }));
+
+            return runningModels;
+        } catch (error) {
+            return [];
+        }
+    }
+
+    async testConnection() {
+        try {
+            // Test 1: Version check
+            const versionController = new AbortController();
+            const versionTimeoutId = setTimeout(() => versionController.abort(), 5000);
+
+            const versionResponse = await fetch(`${this.baseURL}/api/version`, {
+                signal: versionController.signal
+            });
+
+            clearTimeout(versionTimeoutId);
+            
+            if (!versionResponse.ok) {
+                return {
+                    success: false,
+                    error: `Version check failed: ${versionResponse.status}`,
+                    details: 'Ollama might not be running properly'
+                };
+            }
+            
+            const versionData = await versionResponse.json();
+
+            // Test 2: Tags check
+            const tagsController = new AbortController();
+            const tagsTimeoutId = setTimeout(() => tagsController.abort(), 10000);
+
+            const tagsResponse = await fetch(`${this.baseURL}/api/tags`, {
+                signal: tagsController.signal
+            });
+
+            clearTimeout(tagsTimeoutId);
+            
+            if (!tagsResponse.ok) {
+                return {
+                    success: false,
+                    error: `Tags check failed: ${tagsResponse.status}`,
+                    details: 'Could not access models API'
+                };
+            }
+            
+            const tagsText = await tagsResponse.text();
+            let tagsData;
+            
+            try {
+                tagsData = JSON.parse(tagsText);
+            } catch (e) {
+                return {
+                    success: false,
+                    error: 'Invalid JSON in tags response',
+                    details: tagsText.substring(0, 100)
+                };
+            }
+
+            return {
+                success: true,
+                version: versionData.version,
+                modelsFound: tagsData.models ? tagsData.models.length : 0,
+                models: tagsData.models || []
+            };
+            
+        } catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                details: error.code || 'Unknown error'
+            };
+        }
+    }
+
+    parseOllamaModel(ollamaModel) {
+        const sizeBytes = ollamaModel.size || 0;
+        const sizeGB = Math.round(sizeBytes / (1024 ** 3) * 10) / 10;
+
+
+        const [modelFamily, version] = ollamaModel.name.split(':');
+        const details = ollamaModel.details || {};
+
+
+        let estimatedParams = 'Unknown';
+        if (details.parameter_size) {
+            estimatedParams = details.parameter_size;
+        } else if (sizeGB > 0) {
+
+            if (sizeGB < 2) estimatedParams = '1B';
+            else if (sizeGB < 4) estimatedParams = '3B';
+            else if (sizeGB < 6) estimatedParams = '7B';
+            else if (sizeGB < 15) estimatedParams = '8B';
+            else if (sizeGB < 25) estimatedParams = '13B';
+            else if (sizeGB < 45) estimatedParams = '34B';
+            else estimatedParams = '70B+';
+        }
+
+        return {
+            name: ollamaModel.name,
+            displayName: `${modelFamily} ${version || 'latest'}`,
+            family: details.family || modelFamily.toLowerCase(),
+            size: estimatedParams,
+            fileSizeGB: sizeGB,
+            quantization: details.quantization_level || 'Unknown',
+            format: details.format || 'GGUF',
+            digest: ollamaModel.digest,
+            modified: ollamaModel.modified_at,
+            source: 'ollama_local',
+            details: {
+                parameter_size: details.parameter_size,
+                quantization_level: details.quantization_level,
+                families: details.families || [details.family || modelFamily],
+                parent_model: details.parent_model || ''
+            }
+        };
+    }
+
+    async pullModel(modelName, onProgress = null) {
+        const availability = await this.checkOllamaAvailability();
+        if (!availability.available) {
+            throw new Error(`Ollama not available: ${availability.error}`);
+        }
+
+        try {
+            const response = await fetch(`${this.baseURL}/api/pull`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model: modelName, stream: true })
+            });
+
+            if (!response.ok) {
+                throw new Error(`Failed to pull model: HTTP ${response.status}`);
+            }
+
+
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let receivedSuccess = false;
+
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                const chunk = decoder.decode(value);
+                const lines = chunk.split('\n').filter(line => line.trim());
+
+                for (const line of lines) {
+                    try {
+                        const data = JSON.parse(line);
+
+                        if (onProgress && (data.status || data.completed !== undefined)) {
+                            onProgress({
+                                status: data.status,
+                                completed: data.completed,
+                                total: data.total,
+                                percent: data.total ? Math.round((data.completed / data.total) * 100) : 0
+                            });
+                        }
+
+                        if (data.status === 'success') {
+                            receivedSuccess = true;
+                            return { success: true, model: modelName };
+                        }
+
+                        if (data.error) {
+                            throw new Error(data.error);
+                        }
+                    } catch (e) {
+                        if (e.message && !e.message.includes('Unexpected')) {
+                            throw e; // Re-throw real errors, skip JSON parse errors
+                        }
+                    }
+                }
+            }
+
+            if (!receivedSuccess) {
+                throw new Error('Stream ended without success confirmation');
+            }
+
+            return { success: true, model: modelName };
+        } catch (error) {
+            throw new Error(`Failed to pull model: ${error.message}`);
+        }
+    }
+
+    async deleteModel(modelName) {
+        const availability = await this.checkOllamaAvailability();
+        if (!availability.available) {
+            throw new Error(`Ollama not available: ${availability.error}`);
+        }
+
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10000);
+
+            const response = await fetch(`${this.baseURL}/api/delete`, {
+                method: 'DELETE',
+                signal: controller.signal,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model: modelName })
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                throw new Error(`Failed to delete model: HTTP ${response.status}`);
+            }
+
+            return { success: true, model: modelName };
+        } catch (error) {
+            throw new Error(`Failed to delete model: ${error.message}`);
+        }
+    }
+
+    async testModelPerformance(modelName, testPrompt = "Hello, how are you?") {
+        const availability = await this.checkOllamaAvailability();
+        if (!availability.available) {
+            throw new Error(`Ollama not available: ${availability.error}`);
+        }
+
+        const startTime = Date.now();
+
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 30000);
+
+            const response = await fetch(`${this.baseURL}/api/generate`, {
+                method: 'POST',
+                signal: controller.signal,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: modelName,
+                    prompt: testPrompt,
+                    stream: false,
+                    options: {
+                        num_predict: 50 // Limitar respuesta para test rápido
+                    }
+                })
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                throw new Error(`Test failed: HTTP ${response.status}`);
+            }
+
+            const data = await response.json();
+            const endTime = Date.now();
+
+            const totalTime = endTime - startTime;
+            const tokensGenerated = data.eval_count || 50;
+            const tokensPerSecond = Math.round((tokensGenerated / (totalTime / 1000)) * 10) / 10;
+
+            return {
+                success: true,
+                responseTime: totalTime,
+                tokensPerSecond,
+                tokensGenerated,
+                loadTime: data.load_duration ? Math.round(data.load_duration / 1000000) : null,
+                evalTime: data.eval_duration ? Math.round(data.eval_duration / 1000000) : null,
+                response: data.response
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                responseTime: Date.now() - startTime
+            };
+        }
+    }
+}
+
+module.exports = OllamaClient;

package/src/ollama/enhanced-client.js

@@ -0,0 +1,113 @@
+const { OllamaNativeScraper } = require('./native-scraper');
+const OllamaClient = require('./client');
+
+class EnhancedOllamaClient extends OllamaClient {
+    constructor() {
+        super();
+        this.scraper = new OllamaNativeScraper();
+    }
+
+    async getEnhancedCompatibleModels() {
+        try {
+            const localModels = await this.getLocalModels();
+            const compatibility = await this.scraper.findCompatibleModels(localModels);
+
+            const compatible = compatibility.compatible_models.map(match => {
+                return {
+                    name: match.cloud.model_name,
+                    identifier: match.cloud.model_identifier,
+                    description: match.cloud.description,
+                    local_name: match.local.name,
+                    pulls: match.cloud.pulls,
+                    url: match.cloud.url,
+                    match_type: match.match_type,
+                    score: this.calculateCompatibilityScore(match),
+                    size: this.extractSizeFromName(match.cloud.model_identifier),
+                    status: 'INSTALLED',
+                    installation: {
+                        ollama: `ollama pull ${match.cloud.model_identifier}`
+                    }
+                };
+            });
+
+            const allModels = await this.scraper.scrapeAllModels();
+            const recommendations = allModels.models
+                .filter(m => !compatibility.compatible_models.find(c => c.cloud.model_identifier === m.model_identifier))
+                .sort((a, b) => (b.pulls || 0) - (a.pulls || 0))
+                .slice(0, 10)
+                .map(model => ({
+                    name: model.model_name,
+                    identifier: model.model_identifier,
+                    description: model.description,
+                    pulls: model.pulls,
+                    url: model.url,
+                    score: this.calculateRecommendationScore(model),
+                    size: this.extractSizeFromName(model.model_identifier),
+                    installation: {
+                        ollama: `ollama pull ${model.model_identifier}`
+                    }
+                }));
+
+            return {
+                installed: localModels.length,
+                compatible: compatible.length,
+                compatible_models: compatible,
+                recommendations,
+                total_available: allModels.total_count,
+                cache_info: {
+                    cached_at: allModels.cached_at,
+                    expires_at: allModels.expires_at
+                }
+            };
+        } catch (error) {
+            console.error('Error in enhanced compatibility check:', error);
+            return await this.getCompatibleModels();
+        }
+    }
+
+    calculateCompatibilityScore(match) {
+        let score = 75;
+        if (match.match_type === 'exact') score += 20;
+        const pulls = match.cloud.pulls || 0;
+        if (pulls > 1000000) score += 5;
+        if (pulls > 100000) score += 3;
+        if (pulls > 10000) score += 1;
+        return Math.min(100, score);
+    }
+
+    calculateRecommendationScore(model) {
+        let score = 60;
+        const pulls = model.pulls || 0;
+        if (pulls > 10000000) score += 25;
+        else if (pulls > 1000000) score += 20;
+        else if (pulls > 100000) score += 15;
+        else if (pulls > 10000) score += 10;
+        if (model.model_type === 'official') score += 10;
+        return Math.min(100, score);
+    }
+
+    extractSizeFromName(identifier) {
+        const sizeMatch = identifier.match(/(\d+\.?\d*[bm])/i);
+        return sizeMatch ? sizeMatch[1].toUpperCase() : 'Unknown';
+    }
+
+    async searchAvailableModels(query) {
+        const results = await this.scraper.searchModels(query);
+        return results.models.map(model => ({
+            name: model.model_name,
+            identifier: model.model_identifier,
+            description: model.description,
+            pulls: model.pulls,
+            url: model.url,
+            installation: {
+                ollama: `ollama pull ${model.model_identifier}`
+            }
+        }));
+    }
+
+    async getOllamaStats() {
+        return await this.scraper.getStats();
+    }
+}
+
+module.exports = EnhancedOllamaClient;