llm-checker 3.1.0

package/src/utils/config.js

@@ -0,0 +1,359 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class ConfigManager {
+    constructor() {
+        this.configDir = path.join(os.homedir(), '.llm-checker');
+        this.configFile = path.join(this.configDir, 'config.json');
+        this.defaultConfig = this.getDefaultConfig();
+        this.config = null;
+
+        this.ensureConfigDirectory();
+    }
+
+    getDefaultConfig() {
+        return {
+            version: "2.0",
+            ollama: {
+                baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434",
+                timeout: 30000,
+                enabled: true,
+                autoDetect: true,
+                retryAttempts: 3
+            },
+            analysis: {
+                includeCloudModels: false,
+                defaultUseCase: "general",
+                performanceTesting: false,
+                detailedHardwareInfo: false,
+                cacheResults: true,
+                cacheExpiry: 300000
+            },
+            display: {
+                maxModelsPerTable: 10,
+                showEmojis: !process.env.NO_COLOR,
+                colorOutput: !process.env.NO_COLOR,
+                compactMode: false,
+                showScores: true,
+                showInstallCommands: true
+            },
+            quantization: {
+                preferredLevel: "auto",
+                availableLevels: ["Q2_K", "Q3_K_M", "Q4_0", "Q4_K_M", "Q5_0", "Q5_K_M", "Q6_K", "Q8_0"],
+                hardwareBased: {
+                    ultra_low: ["Q2_K", "Q3_K_M"],
+                    low: ["Q4_0", "Q4_K_M"],
+                    medium: ["Q4_K_M", "Q5_0"],
+                    high: ["Q5_K_M", "Q6_K"],
+                    ultra_high: ["Q8_0", "Q6_K"]
+                }
+            },
+            filters: {
+                excludeModels: [],
+                includeOnlyFrameworks: [],
+                excludeCategories: [],
+                minCompatibilityScore: 60,
+                maxModelSize: null,
+                yearFilter: null
+            },
+            hardware: {
+                overrides: {
+                    ram: process.env.LLM_CHECKER_RAM_GB ? (isNaN(parseInt(process.env.LLM_CHECKER_RAM_GB)) ? null : parseInt(process.env.LLM_CHECKER_RAM_GB)) : null,
+                    vram: process.env.LLM_CHECKER_VRAM_GB ? (isNaN(parseInt(process.env.LLM_CHECKER_VRAM_GB)) ? null : parseInt(process.env.LLM_CHECKER_VRAM_GB)) : null,
+                    cpuCores: process.env.LLM_CHECKER_CPU_CORES ? (isNaN(parseInt(process.env.LLM_CHECKER_CPU_CORES)) ? null : parseInt(process.env.LLM_CHECKER_CPU_CORES)) : null,
+                    architecture: process.env.LLM_CHECKER_ARCHITECTURE || null
+                },
+                ignoreIntegratedGPU: process.env.LLM_CHECKER_NO_GPU === 'true',
+                preferDedicatedGPU: true,
+                cacheHardwareInfo: true
+            },
+            recommendations: {
+                maxRecommendations: 5,
+                includeUpgradeSuggestions: true,
+                showPerformanceEstimates: true,
+                groupByCategory: true,
+                prioritizeOllamaSupport: true
+            },
+            logging: {
+                level: process.env.LLM_CHECKER_LOG_LEVEL || "info",
+                file: null,
+                enableDebug: process.env.DEBUG === '1',
+                enableVerbose: false,
+                saveReports: false,
+                reportsDirectory: path.join(os.homedir(), '.llm-checker', 'reports')
+            },
+            updates: {
+                checkForUpdates: true,
+                autoUpdateDatabase: true,
+                updateChannel: "stable",
+                notifyNewModels: true
+            },
+            customModels: []
+        };
+    }
+
+    ensureConfigDirectory() {
+        if (!fs.existsSync(this.configDir)) {
+            try {
+                fs.mkdirSync(this.configDir, { recursive: true });
+            } catch (error) {
+                console.warn(`Warning: Could not create config directory: ${error.message}`);
+            }
+        }
+    }
+
+    loadConfig() {
+        if (this.config) {
+            return this.config;
+        }
+
+        let userConfig = {};
+
+        // Try to load user config file
+        if (fs.existsSync(this.configFile)) {
+            try {
+                const configContent = fs.readFileSync(this.configFile, 'utf8');
+                userConfig = JSON.parse(configContent);
+            } catch (error) {
+                console.warn(`Warning: Could not parse config file: ${error.message}`);
+                console.warn('Using default configuration');
+            }
+        }
+
+        // Merge with defaults
+        this.config = this.mergeConfigs(this.defaultConfig, userConfig);
+
+        // Apply environment variable overrides
+        this.applyEnvironmentOverrides();
+
+        return this.config;
+    }
+
+    saveConfig(config = null) {
+        const configToSave = config || this.config || this.defaultConfig;
+
+        try {
+            const configContent = JSON.stringify(configToSave, null, 2);
+            fs.writeFileSync(this.configFile, configContent, 'utf8');
+            this.config = configToSave;
+            return true;
+        } catch (error) {
+            console.error(`Error saving config: ${error.message}`);
+            return false;
+        }
+    }
+
+    mergeConfigs(defaultConfig, userConfig) {
+        const merged = { ...defaultConfig };
+
+        for (const [key, value] of Object.entries(userConfig)) {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                merged[key] = this.mergeConfigs(defaultConfig[key] || {}, value);
+            } else {
+                merged[key] = value;
+            }
+        }
+
+        return merged;
+    }
+
+    applyEnvironmentOverrides() {
+        if (!this.config) return;
+
+        // Hardware overrides (validate parsed values are valid numbers)
+        if (process.env.LLM_CHECKER_RAM_GB) {
+            const parsed = parseInt(process.env.LLM_CHECKER_RAM_GB);
+            if (!isNaN(parsed) && parsed > 0) this.config.hardware.overrides.ram = parsed;
+        }
+        if (process.env.LLM_CHECKER_VRAM_GB) {
+            const parsed = parseInt(process.env.LLM_CHECKER_VRAM_GB);
+            if (!isNaN(parsed) && parsed > 0) this.config.hardware.overrides.vram = parsed;
+        }
+        if (process.env.LLM_CHECKER_CPU_CORES) {
+            const parsed = parseInt(process.env.LLM_CHECKER_CPU_CORES);
+            if (!isNaN(parsed) && parsed > 0) this.config.hardware.overrides.cpuCores = parsed;
+        }
+
+        // Ollama overrides
+        if (process.env.OLLAMA_BASE_URL) {
+            this.config.ollama.baseURL = process.env.OLLAMA_BASE_URL;
+        }
+
+        // Display overrides
+        if (process.env.NO_COLOR) {
+            this.config.display.colorOutput = false;
+            this.config.display.showEmojis = false;
+        }
+
+        // Debug overrides
+        if (process.env.DEBUG === '1') {
+            this.config.logging.enableDebug = true;
+            this.config.logging.level = 'debug';
+        }
+
+        // GPU overrides
+        if (process.env.LLM_CHECKER_NO_GPU === 'true') {
+            this.config.hardware.ignoreIntegratedGPU = true;
+        }
+    }
+
+    get(keyPath, defaultValue = null) {
+        const config = this.loadConfig();
+        const keys = keyPath.split('.');
+        let value = config;
+
+        for (const key of keys) {
+            if (value && typeof value === 'object' && key in value) {
+                value = value[key];
+            } else {
+                return defaultValue;
+            }
+        }
+
+        return value;
+    }
+
+    set(keyPath, value) {
+        const config = this.loadConfig();
+        const keys = keyPath.split('.');
+        const lastKey = keys.pop();
+
+        let current = config;
+        for (const key of keys) {
+            if (!current[key] || typeof current[key] !== 'object') {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+
+        current[lastKey] = value;
+        this.saveConfig(config);
+
+        return true;
+    }
+
+    reset() {
+        this.config = null;
+        if (fs.existsSync(this.configFile)) {
+            try {
+                fs.unlinkSync(this.configFile);
+            } catch (error) {
+                console.error(`Error removing config file: ${error.message}`);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    exportConfig() {
+        const config = this.loadConfig();
+        return JSON.stringify(config, null, 2);
+    }
+
+    importConfig(configString) {
+        try {
+            const config = JSON.parse(configString);
+            return this.saveConfig(config);
+        } catch (error) {
+            console.error(`Error importing config: ${error.message}`);
+            return false;
+        }
+    }
+
+    validateConfig(config = null) {
+        const configToValidate = config || this.loadConfig();
+        const errors = [];
+
+        // Validate required sections
+        const requiredSections = ['ollama', 'analysis', 'display', 'hardware'];
+        for (const section of requiredSections) {
+            if (!configToValidate[section]) {
+                errors.push(`Missing required section: ${section}`);
+            }
+        }
+
+        // Validate Ollama URL
+        if (configToValidate.ollama?.baseURL) {
+            try {
+                new URL(configToValidate.ollama.baseURL);
+            } catch (error) {
+                errors.push(`Invalid Ollama URL: ${configToValidate.ollama.baseURL}`);
+            }
+        }
+
+        // Validate numeric values
+        if (configToValidate.ollama?.timeout && configToValidate.ollama.timeout < 1000) {
+            errors.push('Ollama timeout should be at least 1000ms');
+        }
+
+        if (configToValidate.display?.maxModelsPerTable && configToValidate.display.maxModelsPerTable < 1) {
+            errors.push('maxModelsPerTable should be at least 1');
+        }
+
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+
+    getConfigPath() {
+        return this.configFile;
+    }
+
+    getConfigDirectory() {
+        return this.configDir;
+    }
+
+    createBackup() {
+        if (!fs.existsSync(this.configFile)) {
+            return null;
+        }
+
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupFile = path.join(this.configDir, `config.backup.${timestamp}.json`);
+
+        try {
+            fs.copyFileSync(this.configFile, backupFile);
+            return backupFile;
+        } catch (error) {
+            console.error(`Error creating backup: ${error.message}`);
+            return null;
+        }
+    }
+
+    listBackups() {
+        try {
+            const files = fs.readdirSync(this.configDir);
+            return files
+                .filter(file => file.startsWith('config.backup.') && file.endsWith('.json'))
+                .map(file => ({
+                    name: file,
+                    path: path.join(this.configDir, file),
+                    created: fs.statSync(path.join(this.configDir, file)).mtime
+                }))
+                .sort((a, b) => b.created - a.created);
+        } catch (error) {
+            console.error(`Error listing backups: ${error.message}`);
+            return [];
+        }
+    }
+
+    restoreBackup(backupName) {
+        const backupPath = path.join(this.configDir, backupName);
+
+        if (!fs.existsSync(backupPath)) {
+            throw new Error(`Backup file not found: ${backupName}`);
+        }
+
+        try {
+            fs.copyFileSync(backupPath, this.configFile);
+            this.config = null; // Force reload
+            return true;
+        } catch (error) {
+            throw new Error(`Error restoring backup: ${error.message}`);
+        }
+    }
+}
+
+module.exports = ConfigManager;

package/src/utils/formatter.js

@@ -0,0 +1,315 @@
+const chalk = require('chalk');
+
+class OutputFormatter {
+    constructor(options = {}) {
+        this.useColors = options.colors !== false && !process.env.NO_COLOR;
+        this.useEmojis = options.emojis !== false && !process.env.NO_EMOJI;
+        this.compact = options.compact || false;
+    }
+
+    formatSystemInfo(hardware) {
+        const lines = [];
+
+        if (!this.compact) {
+            lines.push(this.header('System Information'));
+        }
+
+        lines.push(this.info('CPU', `${hardware.cpu.brand} (${hardware.cpu.cores} cores, ${hardware.cpu.speed || 'Unknown'}GHz)`));
+        lines.push(this.info('Architecture', hardware.cpu.architecture));
+        lines.push(this.info('RAM', `${hardware.memory.total}GB total (${hardware.memory.free}GB free, ${hardware.memory.usagePercent}% used)`));
+        lines.push(this.info('GPU', hardware.gpu.model || 'Not detected'));
+        const vramDisplay = hardware.gpu.vram === 0 && hardware.gpu.model && hardware.gpu.model.toLowerCase().includes('apple') 
+            ? 'Unified Memory' 
+            : `${hardware.gpu.vram || 'N/A'}GB`;
+        lines.push(this.info('VRAM', `${vramDisplay}${hardware.gpu.dedicated ? ' (Dedicated)' : ' (Integrated)'}`));
+        lines.push(this.info('OS', `${hardware.os.distro} ${hardware.os.release} (${hardware.os.arch})`));
+
+        return lines.join('\n');
+    }
+
+    formatCompatibilityResults(results) {
+        const lines = [];
+
+        if (results.compatible.length > 0) {
+            lines.push(this.success('Compatible Models (Score ≥ 75)'));
+            lines.push(this.formatModelsTable(results.compatible, 'compatible'));
+        }
+
+        if (results.marginal.length > 0) {
+            lines.push(this.warning('Marginal Performance (Score 60-74)'));
+            lines.push(this.formatModelsTable(results.marginal, 'marginal'));
+        }
+
+        if (results.incompatible.length > 0 && !this.compact) {
+            lines.push(this.error('Incompatible Models (showing top 5)'));
+            lines.push(this.formatModelsTable(results.incompatible.slice(0, 5), 'incompatible'));
+        }
+
+        return lines.join('\n\n');
+    }
+
+    formatModelsTable(models, type) {
+        if (models.length === 0) return '';
+
+        const headers = ['Model', 'Size', 'Score', 'RAM', 'VRAM', 'Speed'];
+        const rows = [headers];
+
+        models.slice(0, this.compact ? 5 : 10).forEach(model => {
+            const scoreText = `${model.score || 0}/100`;
+            const scoreColored = this.scoreColor(model.score || 0, scoreText);
+
+            rows.push([
+                this.truncate(model.name, 20),
+                model.size || 'Unknown',
+                scoreColored,
+                `${model.requirements?.ram || '?'}GB`,
+                `${model.requirements?.vram || 0}GB`,
+                this.formatSpeed(model.performance?.speed)
+            ]);
+        });
+
+        return this.createTable(rows);
+    }
+
+    formatRecommendations(recommendations) {
+        if (!recommendations || recommendations.length === 0) {
+            return '';
+        }
+
+        const lines = [this.header('Recommendations')];
+
+        recommendations.forEach((rec, index) => {
+            lines.push(`${index + 1}. ${rec}`);
+        });
+
+        return lines.join('\n');
+    }
+
+    formatOllamaStatus(ollamaInfo) {
+        if (!ollamaInfo) return '';
+
+        const status = ollamaInfo.available ?
+            this.success(`Running (v${ollamaInfo.version || 'unknown'})`) :
+            this.error(`${ollamaInfo.error || 'Not available'}`);
+
+        let result = this.info('Ollama Status', status);
+
+        if (ollamaInfo.available) {
+            result += '\n' + this.info('Local Models', `${ollamaInfo.localModels || 0} installed`);
+            if (ollamaInfo.runningModels > 0) {
+                result += '\n' + this.info('Running Models', ollamaInfo.runningModels);
+            }
+        }
+
+        return result;
+    }
+
+    formatHardwareTier(tier, score) {
+        const tierFormatted = tier.replace('_', ' ').toUpperCase();
+        const tierColored = this.tierColor(tier, tierFormatted);
+        return this.info('Hardware Tier', `${tierColored} (Overall Score: ${score}/100)`);
+    }
+
+    formatPerformanceBenchmark(benchmark) {
+        if (!benchmark) return '';
+
+        const lines = [this.header('Performance Benchmark')];
+        lines.push(this.info('CPU Score', `${benchmark.cpu}/100`));
+        lines.push(this.info('Memory Score', `${benchmark.memory}/100`));
+        lines.push(this.info('Overall Score', `${benchmark.overall}/100`));
+
+        return lines.join('\n');
+    }
+
+    formatInstallCommands(commands) {
+        if (!commands || commands.length === 0) return '';
+
+        const lines = [this.header('Quick Install Commands')];
+
+        commands.forEach(cmd => {
+            const status = cmd.isInstalled ?
+                this.success('Installed') :
+                this.dim('Not installed');
+            lines.push(`${status} ${this.highlight(cmd.command)}`);
+        });
+
+        return lines.join('\n');
+    }
+
+    formatUpgradeSuggestions(suggestions) {
+        if (!suggestions || suggestions.length === 0) return '';
+
+        const lines = [this.header('Hardware Upgrade Suggestions')];
+
+        suggestions.forEach((suggestion, index) => {
+            lines.push(`${index + 1}. ${suggestion}`);
+        });
+
+        return lines.join('\n');
+    }
+
+    formatNextSteps(steps) {
+        if (!steps || steps.length === 0) return '';
+
+        const lines = [this.header('Next Steps')];
+
+        steps.forEach((step, index) => {
+            lines.push(`${index + 1}. ${step}`);
+        });
+
+        return lines.join('\n');
+    }
+
+    // Helper methods for styling
+    header(text) {
+        return this.useColors ? chalk.blue.bold(text) : text;
+    }
+
+    success(text) {
+        return this.useColors ? chalk.green(text) : text;
+    }
+
+    warning(text) {
+        return this.useColors ? chalk.yellow(text) : text;
+    }
+
+    error(text) {
+        return this.useColors ? chalk.red(text) : text;
+    }
+
+    info(label, value) {
+        const labelFormatted = this.useColors ? chalk.cyan(label + ':') : label + ':';
+        return `${labelFormatted} ${value}`;
+    }
+
+    highlight(text) {
+        return this.useColors ? chalk.cyan(text) : text;
+    }
+
+    dim(text) {
+        return this.useColors ? chalk.gray(text) : text;
+    }
+
+    scoreColor(score, text) {
+        if (!this.useColors) return text;
+
+        if (score >= 90) return chalk.green(text);
+        if (score >= 75) return chalk.yellow(text);
+        if (score >= 60) return chalk.orange(text);
+        return chalk.red(text);
+    }
+
+    tierColor(tier, text) {
+        if (!this.useColors) return text;
+
+        switch (tier) {
+            case 'ultra_high': return chalk.magenta(text);
+            case 'high': return chalk.green(text);
+            case 'medium': return chalk.yellow(text);
+            case 'low': return chalk.orange(text);
+            case 'ultra_low': return chalk.red(text);
+            default: return text;
+        }
+    }
+
+    formatSpeed(speed) {
+        const speedMap = {
+            'very_fast': 'Very Fast',
+            'fast': 'Fast',
+            'medium': 'Medium',
+            'slow': 'Slow',
+            'very_slow': 'Very Slow'
+        };
+
+        return speedMap[speed] || speed || 'Unknown';
+    }
+
+    truncate(text, maxLength) {
+        if (!text) return '';
+        return text.length > maxLength ? text.substring(0, maxLength - 3) + '...' : text;
+    }
+
+    createTable(rows) {
+        if (rows.length === 0) return '';
+
+        // Calculate column widths
+        const widths = rows[0].map((_, colIndex) =>
+            Math.max(...rows.map(row => this.stripAnsi(row[colIndex] || '').length))
+        );
+
+        const lines = [];
+
+        rows.forEach((row, rowIndex) => {
+            const paddedRow = row.map((cell, colIndex) => {
+                const cellText = cell || '';
+                const padding = widths[colIndex] - this.stripAnsi(cellText).length;
+                return cellText + ' '.repeat(Math.max(0, padding));
+            });
+
+            lines.push('│ ' + paddedRow.join(' │ ') + ' │');
+
+            // Add separator after header
+            if (rowIndex === 0) {
+                const separator = '├' + widths.map(w => '─'.repeat(w + 2)).join('┼') + '┤';
+                lines.push(separator);
+            }
+        });
+
+        // Add top and bottom borders
+        const topBorder = '┌' + widths.map(w => '─'.repeat(w + 2)).join('┬') + '┐';
+        const bottomBorder = '└' + widths.map(w => '─'.repeat(w + 2)).join('┴') + '┘';
+
+        return [topBorder, ...lines, bottomBorder].join('\n');
+    }
+
+    stripAnsi(text) {
+        // Simple ANSI escape code removal
+        return text.replace(/\x1b\[[0-9;]*m/g, '');
+    }
+
+    formatJSON(data, pretty = true) {
+        return JSON.stringify(data, null, pretty ? 2 : 0);
+    }
+
+    formatCSV(data, headers) {
+        const lines = [];
+
+        if (headers) {
+            lines.push(headers.join(','));
+        }
+
+        data.forEach(row => {
+            const csvRow = row.map(cell => {
+                const cellStr = String(cell || '');
+                // Escape quotes and wrap in quotes if necessary
+                if (cellStr.includes(',') || cellStr.includes('"') || cellStr.includes('\n')) {
+                    return '"' + cellStr.replace(/"/g, '""') + '"';
+                }
+                return cellStr;
+            });
+            lines.push(csvRow.join(','));
+        });
+
+        return lines.join('\n');
+    }
+
+    formatMarkdown(data) {
+        // Simple markdown table formatting
+        if (!data || data.length === 0) return '';
+
+        const headers = data[0];
+        const rows = data.slice(1);
+
+        const lines = [];
+        lines.push('| ' + headers.join(' | ') + ' |');
+        lines.push('| ' + headers.map(() => '---').join(' | ') + ' |');
+
+        rows.forEach(row => {
+            lines.push('| ' + row.join(' | ') + ' |');
+        });
+
+        return lines.join('\n');
+    }
+}
+
+module.exports = OutputFormatter;