llm-checker 3.1.0

package/src/data/sync-manager.js

@@ -0,0 +1,279 @@
+/**
+ * Sync Manager - Coordinates scraping and database updates
+ * Handles initial sync and incremental updates
+ */
+
+const ModelDatabase = require('./model-database');
+const EnhancedOllamaScraper = require('../ollama/enhanced-scraper');
+
+class SyncManager {
+    constructor(options = {}) {
+        this.db = options.database || new ModelDatabase();
+        this.scraper = options.scraper || new EnhancedOllamaScraper({
+            concurrency: options.concurrency || 5,
+            rateLimitMs: options.rateLimitMs || 200,
+            onProgress: options.onProgress || this.defaultOnProgress.bind(this),
+            onError: options.onError || console.error
+        });
+
+        this.onProgress = options.onProgress || this.defaultOnProgress.bind(this);
+        this.onError = options.onError || console.error;
+    }
+
+    /**
+     * Default progress handler
+     */
+    defaultOnProgress(info) {
+        if (info.phase === 'details' && info.current && info.total) {
+            const pct = Math.round((info.current / info.total) * 100);
+            process.stdout.write(`\r[${pct}%] ${info.message}    `);
+        } else {
+            console.log(info.message);
+        }
+    }
+
+    /**
+     * Initialize database
+     */
+    async init() {
+        await this.db.initialize();
+    }
+
+    /**
+     * Perform full sync from scratch
+     */
+    async fullSync() {
+        await this.init();
+
+        this.onProgress({ phase: 'start', message: 'Starting full sync...' });
+
+        // Clear existing data
+        this.db.clear();
+
+        // Scrape all models
+        const result = await this.scraper.scrapeAll((model, variants) => {
+            // Save model as we go
+            this.db.upsertModel(model);
+
+            // Save variants
+            for (const variant of variants) {
+                this.db.upsertVariant(variant);
+            }
+        });
+
+        // Update sync timestamp
+        this.db.setLastSync(new Date().toISOString());
+
+        const stats = this.db.getStats();
+
+        this.onProgress({
+            phase: 'complete',
+            message: `Sync complete: ${stats.models} models, ${stats.variants} variants`,
+            stats
+        });
+
+        return stats;
+    }
+
+    /**
+     * Perform incremental sync (update only changed models)
+     */
+    async incrementalSync() {
+        await this.init();
+
+        const lastSync = this.db.getLastSync();
+
+        if (!lastSync) {
+            // No previous sync, do full sync
+            return this.fullSync();
+        }
+
+        this.onProgress({ phase: 'start', message: 'Starting incremental sync...' });
+
+        // Get current model list
+        const modelList = await this.scraper.scrapeModelList();
+
+        // Get existing models from DB
+        const existingModels = new Set(
+            this.db.all(`SELECT id FROM models`).map(m => m.id)
+        );
+
+        // Find new and potentially updated models
+        const newModels = modelList.filter(m => !existingModels.has(m.id));
+        const toUpdate = modelList.filter(m => existingModels.has(m.id));
+
+        this.onProgress({
+            phase: 'incremental',
+            message: `Found ${newModels.length} new models, checking ${toUpdate.length} for updates...`
+        });
+
+        let updated = 0;
+        let added = 0;
+
+        // Process new models
+        for (const { id } of newModels) {
+            try {
+                const model = await this.scraper.scrapeModelDetails(id);
+                if (model) {
+                    this.db.upsertModel(model);
+                    added++;
+
+                    const variants = await this.scraper.scrapeModelTags(id);
+                    for (const variant of variants) {
+                        this.db.upsertVariant(variant);
+                    }
+                }
+
+                await this.sleep(200);
+            } catch (error) {
+                this.onError(`Error syncing ${id}: ${error.message}`);
+            }
+        }
+
+        // Check for updates in existing models (sample top 50 by pulls)
+        const topModels = toUpdate.sort((a, b) => (b.pulls || 0) - (a.pulls || 0)).slice(0, 50);
+
+        for (const { id } of topModels) {
+            try {
+                const model = await this.scraper.scrapeModelDetails(id);
+                if (model) {
+                    const existing = this.db.get(`SELECT pulls, tags_count FROM models WHERE id = ?`, [id]);
+
+                    // Update if pulls or tags changed significantly
+                    if (!existing ||
+                        Math.abs((existing.pulls || 0) - (model.pulls || 0)) > 1000 ||
+                        (existing.tags_count || 0) !== (model.tags_count || 0)) {
+
+                        this.db.upsertModel(model);
+
+                        const variants = await this.scraper.scrapeModelTags(id);
+                        for (const variant of variants) {
+                            this.db.upsertVariant(variant);
+                        }
+
+                        updated++;
+                    }
+                }
+
+                await this.sleep(100);
+            } catch (error) {
+                // Ignore errors during incremental update
+            }
+        }
+
+        // Update sync timestamp
+        this.db.setLastSync(new Date().toISOString());
+
+        const stats = this.db.getStats();
+
+        this.onProgress({
+            phase: 'complete',
+            message: `Incremental sync complete: ${added} added, ${updated} updated`,
+            stats
+        });
+
+        return { added, updated, stats };
+    }
+
+    /**
+     * Smart sync - chooses full or incremental based on conditions
+     */
+    async sync(options = {}) {
+        await this.init();
+
+        const force = options.force || false;
+        const lastSync = this.db.getLastSync();
+        const modelCount = this.db.getModelCount();
+
+        // Full sync if:
+        // - Force flag is set
+        // - No previous sync
+        // - Less than 100 models (probably incomplete)
+        // - Last sync was more than 7 days ago
+        if (force || !lastSync || modelCount < 100) {
+            return this.fullSync();
+        }
+
+        const lastSyncDate = new Date(lastSync);
+        const daysSinceSync = (Date.now() - lastSyncDate.getTime()) / (1000 * 60 * 60 * 24);
+
+        if (daysSinceSync > 7) {
+            return this.fullSync();
+        }
+
+        return this.incrementalSync();
+    }
+
+    /**
+     * Check if sync is needed
+     */
+    async needsSync() {
+        await this.init();
+
+        const lastSync = this.db.getLastSync();
+        const modelCount = this.db.getModelCount();
+
+        if (!lastSync || modelCount < 100) {
+            return { needed: true, reason: 'No previous sync or incomplete data' };
+        }
+
+        const lastSyncDate = new Date(lastSync);
+        const hoursSinceSync = (Date.now() - lastSyncDate.getTime()) / (1000 * 60 * 60);
+
+        if (hoursSinceSync > 24) {
+            return { needed: true, reason: `Last sync was ${Math.round(hoursSinceSync)} hours ago` };
+        }
+
+        return { needed: false, stats: this.db.getStats() };
+    }
+
+    /**
+     * Get database stats
+     */
+    async getStats() {
+        await this.init();
+        return this.db.getStats();
+    }
+
+    /**
+     * Search models
+     */
+    async search(query, filters = {}) {
+        await this.init();
+        return this.db.searchModels(query, filters);
+    }
+
+    /**
+     * Search for variants (not just models)
+     */
+    async searchVariants(query, filters = {}) {
+        await this.init();
+        return this.db.searchVariants(query, filters);
+    }
+
+    /**
+     * Get variants for hardware constraints
+     */
+    async getCompatibleVariants(maxSizeGB, filters = {}) {
+        await this.init();
+        return this.db.getVariantsForHardware(maxSizeGB, filters);
+    }
+
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    /**
+     * Close database connection
+     */
+    close() {
+        if (this.db) {
+            this.db.close();
+        }
+    }
+}
+
+module.exports = SyncManager;

package/src/hardware/CLAUDE.md

@@ -0,0 +1,12 @@
+<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 |
+|----|------|---|-------|------|
+| #3490 | 10:24 PM | 🔵 | Hardware Detector Cache Implementation - 5-Minute TTL Without Force Refresh Option | ~536 |
+| #3440 | 9:58 PM | 🔵 | Hardware Detection System - Multi-GPU Support with Intelligent Selection | ~611 |
+</claude-mem-context>

package/src/hardware/backends/CLAUDE.md

@@ -0,0 +1,11 @@
+<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 |
+|----|------|---|-------|------|
+| #3453 | 10:01 PM | 🔵 | CUDA Detector Implementation - NVIDIA GPU Detection via nvidia-smi | ~497 |
+</claude-mem-context>

package/src/hardware/backends/apple-silicon.js

@@ -0,0 +1,318 @@
+/**
+ * Apple Silicon Detector
+ * Detects M1, M2, M3, M4 chips and their capabilities
+ * Uses sysctl and system_profiler for accurate detection
+ */
+
+const { execSync } = require('child_process');
+
+class AppleSiliconDetector {
+    constructor() {
+        this.cache = null;
+        this.isSupported = process.platform === 'darwin' && process.arch === 'arm64';
+    }
+
+    /**
+     * Detect if running on Apple Silicon
+     */
+    detect() {
+        if (!this.isSupported) {
+            return null;
+        }
+
+        if (this.cache) {
+            return this.cache;
+        }
+
+        try {
+            const info = this.getChipInfo();
+            this.cache = info;
+            return info;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Get detailed chip information using sysctl
+     */
+    getChipInfo() {
+        const result = {
+            chip: null,
+            variant: null,  // base, pro, max, ultra
+            generation: null,  // 1, 2, 3, 4
+            cores: {
+                performance: 0,
+                efficiency: 0,
+                total: 0
+            },
+            gpu: {
+                cores: 0,
+                model: null
+            },
+            neuralEngine: {
+                cores: 0
+            },
+            memory: {
+                unified: 0,
+                bandwidth: null
+            },
+            capabilities: {
+                metal: true,
+                metalVersion: null,
+                fp16: true,
+                int8: true,
+                amx: true
+            },
+            backend: 'metal',
+            speedCoefficient: 0
+        };
+
+        // Get chip brand
+        try {
+            const brand = execSync('sysctl -n machdep.cpu.brand_string', { encoding: 'utf8', timeout: 5000 }).trim();
+            result.chip = brand;
+
+            // Parse chip variant and generation
+            const parsed = this.parseChipBrand(brand);
+            result.variant = parsed.variant;
+            result.generation = parsed.generation;
+        } catch (e) {
+            // Fallback
+        }
+
+        // Get CPU cores
+        try {
+            result.cores.total = parseInt(execSync('sysctl -n hw.ncpu', { encoding: 'utf8', timeout: 5000 }).trim());
+            result.cores.performance = parseInt(execSync('sysctl -n hw.perflevel0.logicalcpu', { encoding: 'utf8', timeout: 5000 }).trim()) || Math.ceil(result.cores.total / 2);
+            result.cores.efficiency = parseInt(execSync('sysctl -n hw.perflevel1.logicalcpu', { encoding: 'utf8', timeout: 5000 }).trim()) || Math.floor(result.cores.total / 2);
+        } catch (e) {
+            result.cores.total = require('os').cpus().length;
+        }
+
+        // Get memory (unified memory on Apple Silicon)
+        try {
+            const memBytes = parseInt(execSync('sysctl -n hw.memsize', { encoding: 'utf8', timeout: 5000 }).trim());
+            result.memory.unified = Math.round(memBytes / (1024 ** 3));
+        } catch (e) {
+            result.memory.unified = Math.round(require('os').totalmem() / (1024 ** 3));
+        }
+
+        // Get GPU cores from system_profiler
+        try {
+            const gpuInfo = execSync('system_profiler SPDisplaysDataType -json', {
+                encoding: 'utf8',
+                timeout: 5000
+            });
+            const parsed = JSON.parse(gpuInfo);
+            const displays = parsed.SPDisplaysDataType || [];
+
+            if (displays.length > 0) {
+                const gpu = displays[0];
+                result.gpu.model = gpu.sppci_model || result.chip;
+
+                // Parse GPU cores from model name or estimate
+                const coreMatch = gpu.sppci_cores?.match(/(\d+)/);
+                if (coreMatch) {
+                    result.gpu.cores = parseInt(coreMatch[1]);
+                } else {
+                    result.gpu.cores = this.estimateGPUCores(result.variant, result.generation);
+                }
+            }
+        } catch (e) {
+            result.gpu.cores = this.estimateGPUCores(result.variant, result.generation);
+            result.gpu.model = result.chip;
+        }
+
+        // Get Metal version
+        try {
+            const metalVersion = execSync('system_profiler SPDisplaysDataType | grep "Metal Support"', {
+                encoding: 'utf8',
+                timeout: 5000
+            });
+            const match = metalVersion.match(/Metal\s*([\d.]+|Family)/i);
+            if (match) {
+                result.capabilities.metalVersion = match[1];
+            }
+        } catch (e) {
+            result.capabilities.metalVersion = '3';  // Apple Silicon supports Metal 3
+        }
+
+        // Calculate speed coefficient for LLM inference
+        result.speedCoefficient = this.calculateSpeedCoefficient(result);
+        result.memory.bandwidth = this.estimateMemoryBandwidth(result.variant, result.generation);
+
+        return result;
+    }
+
+    /**
+     * Parse chip brand string to extract variant and generation
+     */
+    parseChipBrand(brand) {
+        const result = { variant: 'base', generation: 1 };
+
+        const brandLower = brand.toLowerCase();
+
+        // Detect generation
+        if (brandLower.includes('m4')) result.generation = 4;
+        else if (brandLower.includes('m3')) result.generation = 3;
+        else if (brandLower.includes('m2')) result.generation = 2;
+        else if (brandLower.includes('m1')) result.generation = 1;
+
+        // Detect variant
+        if (brandLower.includes('ultra')) result.variant = 'ultra';
+        else if (brandLower.includes('max')) result.variant = 'max';
+        else if (brandLower.includes('pro')) result.variant = 'pro';
+        else result.variant = 'base';
+
+        return result;
+    }
+
+    /**
+     * Estimate GPU cores based on variant and generation
+     */
+    estimateGPUCores(variant, generation) {
+        const coreMap = {
+            // M1 series
+            '1-base': 8,
+            '1-pro': 16,
+            '1-max': 32,
+            '1-ultra': 64,
+            // M2 series
+            '2-base': 10,
+            '2-pro': 19,
+            '2-max': 38,
+            '2-ultra': 76,
+            // M3 series
+            '3-base': 10,
+            '3-pro': 18,
+            '3-max': 40,
+            '3-ultra': 80,
+            // M4 series
+            '4-base': 10,
+            '4-pro': 20,
+            '4-max': 40,
+            '4-ultra': 80
+        };
+
+        return coreMap[`${generation}-${variant}`] || 10;
+    }
+
+    /**
+     * Estimate memory bandwidth in GB/s
+     */
+    estimateMemoryBandwidth(variant, generation) {
+        const bandwidthMap = {
+            // M1 series
+            '1-base': 68,
+            '1-pro': 200,
+            '1-max': 400,
+            '1-ultra': 800,
+            // M2 series
+            '2-base': 100,
+            '2-pro': 200,
+            '2-max': 400,
+            '2-ultra': 800,
+            // M3 series
+            '3-base': 100,
+            '3-pro': 150,
+            '3-max': 400,
+            '3-ultra': 800,
+            // M4 series
+            '4-base': 120,
+            '4-pro': 273,
+            '4-max': 546,
+            '4-ultra': 800
+        };
+
+        return bandwidthMap[`${generation}-${variant}`] || 100;
+    }
+
+    /**
+     * Calculate speed coefficient for LLM inference (tokens/sec per B params)
+     */
+    calculateSpeedCoefficient(info) {
+        // Base coefficient by generation and variant
+        const baseCoefficients = {
+            '1-base': 180,
+            '1-pro': 200,
+            '1-max': 220,
+            '1-ultra': 240,
+            '2-base': 200,
+            '2-pro': 220,
+            '2-max': 240,
+            '2-ultra': 260,
+            '3-base': 220,
+            '3-pro': 240,
+            '3-max': 260,
+            '3-ultra': 280,
+            '4-base': 240,
+            '4-pro': 270,
+            '4-max': 300,
+            '4-ultra': 320
+        };
+
+        const key = `${info.generation}-${info.variant}`;
+        return baseCoefficients[key] || 180;
+    }
+
+    /**
+     * Check if Ollama is using Metal backend
+     */
+    async checkMetalSupport() {
+        if (!this.isSupported) {
+            return false;
+        }
+
+        try {
+            // Check if Metal framework is available
+            const metalCheck = execSync('ls /System/Library/Frameworks/Metal.framework', {
+                encoding: 'utf8',
+                timeout: 2000
+            });
+            return metalCheck.includes('Metal');
+        } catch (e) {
+            return true;  // Assume Metal is available on Apple Silicon
+        }
+    }
+
+    /**
+     * Get hardware fingerprint for benchmarks
+     */
+    getFingerprint() {
+        const info = this.detect();
+        if (!info) return null;
+
+        return `apple-${info.chip.toLowerCase().replace(/\s+/g, '-')}-${info.memory.unified}gb`;
+    }
+
+    /**
+     * Estimate inference speed for a model size
+     */
+    estimateTokensPerSecond(paramsB, quantization = 'Q4_K_M') {
+        const info = this.detect();
+        if (!info) return 0;
+
+        // Quantization multipliers (how much faster vs FP16)
+        const quantMult = {
+            'FP16': 1.0,
+            'Q8_0': 1.5,
+            'Q6_K': 1.8,
+            'Q5_K_M': 2.0,
+            'Q5_0': 2.0,
+            'Q4_K_M': 2.5,
+            'Q4_0': 2.8,
+            'Q3_K_M': 3.0,
+            'Q2_K': 3.5,
+            'IQ4_XS': 2.6,
+            'IQ3_XXS': 3.2
+        };
+
+        const mult = quantMult[quantization] || 2.0;
+        const baseSpeed = info.speedCoefficient / paramsB * mult;
+
+        return Math.round(baseSpeed);
+    }
+}
+
+module.exports = AppleSiliconDetector;