llm-checker 3.1.0

package/src/utils/logger.js

@@ -0,0 +1,272 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class Logger {
+    constructor(options = {}) {
+        this.level = options.level || process.env.LLM_CHECKER_LOG_LEVEL || 'info';
+        this.enableColors = options.colors !== false && !process.env.NO_COLOR;
+        this.logFile = options.logFile || null;
+        this.enableConsole = options.console !== false;
+        this.enableDebug = options.debug || process.env.DEBUG === '1';
+
+        this.levels = {
+            error: 0,
+            warn: 1,
+            info: 2,
+            debug: 3,
+            trace: 4
+        };
+
+        this.colors = {
+            error: '\x1b[31m', // Red
+            warn: '\x1b[33m',  // Yellow
+            info: '\x1b[36m',  // Cyan
+            debug: '\x1b[35m', // Magenta
+            trace: '\x1b[37m', // White
+            reset: '\x1b[0m'
+        };
+
+        this.setupLogFile();
+    }
+
+    setupLogFile() {
+        if (this.logFile) {
+            const logDir = path.dirname(this.logFile);
+            if (!fs.existsSync(logDir)) {
+                try {
+                    fs.mkdirSync(logDir, { recursive: true });
+                } catch (error) {
+                    console.warn(`Warning: Could not create log directory: ${error.message}`);
+                    this.logFile = null;
+                }
+            }
+        }
+    }
+
+    shouldLog(level) {
+        return this.levels[level] <= this.levels[this.level];
+    }
+
+    formatMessage(level, message, meta = {}) {
+        const timestamp = new Date().toISOString();
+        const levelUpper = level.toUpperCase();
+
+        let formatted = `${timestamp} [${levelUpper}]`;
+
+        if (meta.component) {
+            formatted += ` [${meta.component}]`;
+        }
+
+        formatted += ` ${message}`;
+
+        if (meta.data && typeof meta.data === 'object') {
+            formatted += '\n' + JSON.stringify(meta.data, null, 2);
+        }
+
+        if (meta.error && meta.error instanceof Error) {
+            formatted += '\n' + meta.error.stack;
+        }
+
+        return formatted;
+    }
+
+    colorize(level, message) {
+        if (!this.enableColors) return message;
+        return this.colors[level] + message + this.colors.reset;
+    }
+
+    writeToFile(message) {
+        if (!this.logFile) return;
+
+        try {
+            fs.appendFileSync(this.logFile, message + '\n', 'utf8');
+        } catch (error) {
+            // Fallback to console if file write fails
+            if (this.enableConsole) {
+                console.error('Failed to write to log file:', error.message);
+            }
+        }
+    }
+
+    log(level, message, meta = {}) {
+        if (!this.shouldLog(level)) return;
+
+        const formatted = this.formatMessage(level, message, meta);
+
+        // Write to console
+        if (this.enableConsole) {
+            const colored = this.colorize(level, formatted);
+
+            if (level === 'error') {
+                console.error(colored);
+            } else if (level === 'warn') {
+                console.warn(colored);
+            } else {
+                console.log(colored);
+            }
+        }
+
+        // Write to file
+        this.writeToFile(formatted);
+    }
+
+    error(message, meta = {}) {
+        this.log('error', message, meta);
+    }
+
+    warn(message, meta = {}) {
+        this.log('warn', message, meta);
+    }
+
+    info(message, meta = {}) {
+        this.log('info', message, meta);
+    }
+
+    debug(message, meta = {}) {
+        this.log('debug', message, meta);
+    }
+
+    trace(message, meta = {}) {
+        this.log('trace', message, meta);
+    }
+
+    // Specialized logging methods
+    logHardwareDetection(hardware) {
+        this.debug('Hardware detection completed', {
+            component: 'HardwareDetector',
+            data: {
+                cpu: hardware.cpu.brand,
+                ram: `${hardware.memory.total}GB`,
+                gpu: hardware.gpu.model,
+                architecture: hardware.cpu.architecture
+            }
+        });
+    }
+
+    logModelAnalysis(model, score) {
+        this.debug('Model compatibility analyzed', {
+            component: 'CompatibilityAnalyzer',
+            data: {
+                model: model.name,
+                score: score,
+                category: model.category
+            }
+        });
+    }
+
+    logOllamaOperation(operation, model, result) {
+        this.info(`Ollama ${operation} ${result ? 'succeeded' : 'failed'}`, {
+            component: 'OllamaClient',
+            data: {
+                operation,
+                model,
+                success: result
+            }
+        });
+    }
+
+    logPerformanceTest(model, results) {
+        this.info('Performance test completed', {
+            component: 'PerformanceAnalyzer',
+            data: {
+                model,
+                tokensPerSecond: results.tokensPerSecond,
+                responseTime: results.responseTime
+            }
+        });
+    }
+
+    logError(error, context = {}) {
+        this.error(error.message, {
+            component: context.component || 'Unknown',
+            error: error,
+            data: context.data
+        });
+    }
+
+    // Utility methods
+    time(label) {
+        const start = process.hrtime.bigint();
+        return {
+            end: () => {
+                const end = process.hrtime.bigint();
+                const duration = Number(end - start) / 1000000; // Convert to milliseconds
+                this.debug(`Timer: ${label} took ${duration.toFixed(2)}ms`);
+                return duration;
+            }
+        };
+    }
+
+    createChild(component) {
+        return {
+            error: (message, meta = {}) => this.error(message, { ...meta, component }),
+            warn: (message, meta = {}) => this.warn(message, { ...meta, component }),
+            info: (message, meta = {}) => this.info(message, { ...meta, component }),
+            debug: (message, meta = {}) => this.debug(message, { ...meta, component }),
+            trace: (message, meta = {}) => this.trace(message, { ...meta, component })
+        };
+    }
+
+    getLogFile() {
+        return this.logFile;
+    }
+
+    setLogFile(filePath) {
+        this.logFile = filePath;
+        this.setupLogFile();
+    }
+
+    setLevel(level) {
+        if (this.levels.hasOwnProperty(level)) {
+            this.level = level;
+        } else {
+            this.warn(`Invalid log level: ${level}. Valid levels: ${Object.keys(this.levels).join(', ')}`);
+        }
+    }
+
+    clearLogFile() {
+        if (this.logFile && fs.existsSync(this.logFile)) {
+            try {
+                fs.writeFileSync(this.logFile, '', 'utf8');
+                this.info('Log file cleared');
+            } catch (error) {
+                this.error('Failed to clear log file', { error });
+            }
+        }
+    }
+
+    rotateLogFile() {
+        if (!this.logFile || !fs.existsSync(this.logFile)) return;
+
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const rotatedFile = this.logFile + '.' + timestamp;
+
+            fs.renameSync(this.logFile, rotatedFile);
+            this.info(`Log file rotated to: ${rotatedFile}`);
+        } catch (error) {
+            this.error('Failed to rotate log file', { error });
+        }
+    }
+}
+
+// Global logger instance
+let globalLogger = null;
+
+function getLogger(options = {}) {
+    if (!globalLogger) {
+        globalLogger = new Logger(options);
+    }
+    return globalLogger;
+}
+
+function setLogger(logger) {
+    globalLogger = logger;
+}
+
+module.exports = {
+    Logger,
+    getLogger,
+    setLogger
+};

package/src/utils/model-classifier.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+// model-classifier.js
+// Classifier that adds `categories` (multi) and `primary_category` (single) to each model
+//
+// IMPORTANT: STATIC DATABASE WITH PRE-CLASSIFIED CATEGORIES
+// This system uses a static model database (177 models) with pre-classified categories.
+// If you need to update the model database in the future:
+// 1. Run the database update process
+// 2. RE-ADD CATEGORIES: Run this classification system again on all new models
+// 3. Update the cache file with the new categories
+// 4. Test all use-case filters (coding, creative, reasoning, multimodal, embeddings, etc.)
+// 
+// The classification rules below must be applied to any new models added to the database.
+
+const fs = require('fs');
+
+const CANON = ['coding','reasoning','creative','chat','multimodal','embeddings','safety','general'];
+
+const CATEGORY_SYNONYMS = {
+  // normalize incoming "category" values
+  talking: 'chat',
+  multimodal: 'multimodal',
+  embeddings: 'embeddings',
+  reasoning: 'reasoning',
+  coding: 'coding',
+  safety: 'safety',
+  general: 'general',
+};
+
+const RULES = [
+  // embeddings - very specific patterns
+  {cat:'embeddings', re: /(embedding|embed|e5|bge|gte|minilm|paraphrase|text-embedding|nomic[-\s]?embed|voyage|snowflake-embed|arctic-embed|mxbai-embed)/i},
+
+  // multimodal / vision - specific vision models
+  {cat:'multimodal', re: /(llava|vision|vl\b|moondream|paligemma|pixtral|idefics|granite.*vision|llama3\.2[-_ ]?vision|qwen.*vl)/i},
+
+  // safety/moderation
+  {cat:'safety', re: /(guard|shield|moderation|safety)/i},
+
+  // coding - be more specific, exclude general models
+  {cat:'coding', re: /^(code|coder|codellama|starcoder|magicoder|phind[-_ ]?codellama|codeqwen|granite[-_ ]?code|yi[-_ ]?coder|opencoder|stable[-_ ]?code|deepseek[-_ ]?coder|codegemma)/i},
+
+  // reasoning / math
+  {cat:'reasoning', re: /(deepseek[-_ ]?r1|reason|r1\b|math|mathstral|wizard[-_ ]?math|gsm8k|mmlu|logic|phi4[-_ ]?reasoning|o1\b)/i},
+
+  // creative / RP / storytelling - look for specific creative models
+  {cat:'creative', re: /(dolphin(?![-_ ]?coder)|wizard(?![-_ ]?math)|mytho|synthia|airoboros|uncensored|roleplay|storyteller|creative|fiction)/i},
+
+  // chat / assistants - general conversational models
+  {cat:'chat', re: /(llama(?!.*code)|mistral(?!.*code)|qwen(?!.*code|.*vl)|gemma(?!.*code)|chat|assistant|hermes|openhermes|command\b|mistrallite|reflection)/i},
+];
+
+const PRIMARY_ORDER = [
+  'embeddings','safety','coding','reasoning','creative','multimodal','chat','general'
+];
+
+function toText(model) {
+  return [
+    model.model_identifier, model.model_name,
+    model.description, model.detailed_description,
+    model.category, model.use_cases, model.input_types,
+    model.tags, model.labels, model.url
+  ]
+    .flat().filter(Boolean).map(String).join(' ').toLowerCase();
+}
+
+function normalizeFromCategoryField(cat) {
+  if (!cat) return [];
+  const c = CATEGORY_SYNONYMS[String(cat).toLowerCase()];
+  return c ? [c] : [];
+}
+
+function fromUseCases(use_cases=[]) {
+  const set = new Set();
+  for (const u of use_cases.map(x => String(x).toLowerCase())) {
+    if (/(coding|programming|development)/.test(u)) set.add('coding');
+    if (/(reasoning|mathematics|logic)/.test(u)) set.add('reasoning');
+    if (/(chat|conversation|assistant)/.test(u)) set.add('chat');
+    if (/(vision|image|multimodal)/.test(u)) set.add('multimodal');
+    if (/(embedding|embeddings|search|similarity)/.test(u)) set.add('embeddings');
+    if (/(safety|moderation)/.test(u)) set.add('safety');
+    if (/(creative|story|roleplay)/.test(u)) set.add('creative');
+  }
+  return [...set];
+}
+
+function fromInputTypes(input_types=[]) {
+  const set = new Set();
+  const low = input_types.map(x => String(x).toLowerCase());
+  // Only use input_types as hints, not definitive classification
+  // Most models have ['text', 'image', 'code'] automatically, so ignore generic ones
+  if (low.includes('image') && low.length === 1) set.add('multimodal'); // only if pure image model
+  if (low.includes('audio') && low.length === 1) set.add('multimodal'); // only if pure audio model
+  // Don't auto-classify as coding based on input_types since all models have 'code'
+  return [...set];
+}
+
+function regexRules(haystack) {
+  const set = new Set();
+  for (const {cat, re} of RULES) if (re.test(haystack)) set.add(cat);
+  return [...set];
+}
+
+function choosePrimary(cats) {
+  for (const c of PRIMARY_ORDER) if (cats.has(c)) return c;
+  return 'general';
+}
+
+function classifyModel(m) {
+  const hay = toText(m);
+  const cats = new Set([
+    ...normalizeFromCategoryField(m.category),
+    ...fromUseCases(m.use_cases),
+    ...fromInputTypes(m.input_types),
+    ...regexRules(hay),
+  ]);
+
+  if (cats.size === 0) cats.add('general');
+
+  // Keep only canonical labels
+  for (const c of [...cats]) if (!CANON.includes(c)) cats.delete(c);
+
+  const primary = choosePrimary(cats);
+  const categories = [...cats].sort();
+
+  // Also annotate variants (handy for tag-level filtering)
+  const variants = (m.variants || []).map(v => {
+    const vHay = [m.model_name, v.tag, v.size, v.quantization].filter(Boolean).join(' ').toLowerCase();
+    const vCats = new Set(categories);
+    regexRules(vHay).forEach(c => vCats.add(c));
+    return { ...v, categories: [...vCats].sort() };
+  });
+
+  return { ...m, categories, primary_category: primary, variants };
+}
+
+function classifyAllModels(inputData) {
+  const models = inputData.models || [];
+  const classifiedModels = models.map(classifyModel);
+  return { ...inputData, models: classifiedModels };
+}
+
+function run(path) {
+  try {
+    const input = JSON.parse(fs.readFileSync(path, 'utf8'));
+    const output = classifyAllModels(input);
+    console.log(JSON.stringify(output, null, 2));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      console.error(`Invalid JSON in file: ${path}`, error.message);
+    } else {
+      console.error(`Error reading file: ${path}`, error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  const path = process.argv[2];
+  if (!path) {
+    console.error('Usage: node model-classifier.js models.json > models_with_categories.json');
+    process.exit(1);
+  }
+  run(path);
+}
+
+module.exports = { classifyAllModels, classifyModel };

package/src/utils/verbose-progress.js

@@ -0,0 +1,266 @@
+const chalk = require('chalk');
+const ora = require('ora');
+
+/**
+ * Verbose Progress Reporter - Enhanced Visual Style
+ * Muestra operaciones paso a paso con barras de progreso y spinners
+ */
+class VerboseProgress {
+    constructor(enabled = true) {
+        this.enabled = enabled;
+        this.currentStep = 0;
+        this.totalSteps = 0;
+        this.operationTitle = '';
+        this.startTime = null;
+        this.stepTimes = [];
+        this.currentSpinner = null;
+        this.stepStartTime = null;
+    }
+
+    /**
+     * Inicia una nueva operación con múltiples pasos
+     */
+    startOperation(title, totalSteps) {
+        if (!this.enabled) return;
+        
+        this.operationTitle = title;
+        this.totalSteps = totalSteps;
+        this.currentStep = 0;
+        this.startTime = Date.now();
+        this.stepTimes = [];
+        
+        console.log(''); // Espacio inicial
+    }
+
+    /**
+     * Avanza al siguiente paso de la operación
+     */
+    step(description, details = null) {
+        if (!this.enabled) return;
+        
+        // Finalizar spinner anterior si existe (disabled)
+        if (this.currentSpinner) {
+            // this.currentSpinner.stop(); // Disabled to prevent UI issues
+        }
+        
+        this.currentStep++;
+        this.stepStartTime = Date.now();
+        
+        // Crear indicador de progreso visual
+        const progress = this.createProgressBar();
+        const stepIndicator = chalk.cyan(`[${this.currentStep}/${this.totalSteps}]`);
+        
+        // Mostrar el paso actual
+        console.log(`\n${progress} ${stepIndicator} ${chalk.white.bold(description)}`);
+        
+        if (details) {
+            console.log(`    ${chalk.gray('└─ ' + details)}`);
+        }
+        
+        // Crear spinner para este paso (disabled to fix UI issues)
+        this.currentSpinner = null;
+        
+        this.stepTimes.push(this.stepStartTime);
+        
+        return this;
+    }
+
+    /**
+     * Muestra progreso dentro de un paso (sub-operación)
+     */
+    substep(description, isLast = false) {
+        if (!this.enabled) return;
+        
+        const connector = isLast ? '└─' : '├─';
+        const elapsed = this.getStepElapsedTime();
+        console.log(`    ${chalk.gray(connector)} ${description} ${chalk.dim(`(${elapsed})`)}`);
+        
+        return this;
+    }
+
+    /**
+     * Marca el paso actual como completado exitosamente
+     */
+    stepComplete(result = null, timing = null) {
+        if (!this.enabled) return;
+        
+        if (result) {
+            console.log(`      ${chalk.green(result)}`);
+        }
+        
+        // Mostrar timing
+        const elapsed = this.getStepElapsedTime();
+        console.log(`    ${chalk.dim(`└─ ${elapsed}`)}`);
+        
+        return this;
+    }
+
+    /**
+     * Marca el paso actual como fallido
+     */
+    stepFail(error = null) {
+        if (!this.enabled) return;
+        
+        if (error) {
+            console.log(`      ${chalk.red(error)}`);
+        }
+        
+        return this;
+    }
+
+    /**
+     * Muestra información adicional durante un paso
+     */
+    info(message, indent = true) {
+        if (!this.enabled) return;
+        
+        const prefix = indent ? '    ' : '';
+        console.log(`${prefix}${chalk.gray(message)}`);
+        
+        return this;
+    }
+
+    /**
+     * Muestra una advertencia
+     */
+    warn(message, indent = true) {
+        if (!this.enabled) return;
+        
+        const prefix = indent ? '    ' : '';
+        console.log(`${prefix}${chalk.yellow(message)}`);
+        
+        return this;
+    }
+
+    /**
+     * Muestra resultados o datos encontrados
+     */
+    found(message, count = null, indent = true) {
+        if (!this.enabled) return;
+        
+        const prefix = indent ? '    ' : '';
+        const countStr = count !== null ? chalk.cyan.bold(` (${count})`) : '';
+        console.log(`${prefix}${chalk.white(message)}${countStr}`);
+        
+        return this;
+    }
+
+    /**
+     * Finaliza la operación completa
+     */
+    complete(summary = null) {
+        if (!this.enabled) return;
+        
+        // Finalizar spinner si existe (disabled)
+        if (this.currentSpinner) {
+            // this.currentSpinner.stop(); // Disabled to prevent UI issues
+            this.currentSpinner = null;
+        }
+        
+        const totalTime = this.getTotalElapsedTime();
+        
+        console.log(chalk.gray('─'.repeat(60)));
+        
+        if (summary) {
+            console.log(chalk.green.bold(`${this.operationTitle} complete!`));
+            console.log(chalk.gray(`   ${summary}`));
+        } else {
+            console.log(chalk.green.bold(`Operation complete!`));
+        }
+        
+        console.log(chalk.dim(`   Total time: ${totalTime}`));
+        console.log('');
+        
+        return this;
+    }
+
+    /**
+     * Finaliza la operación con error
+     */
+    fail(error = null) {
+        if (!this.enabled) return;
+        
+        // Finalizar spinner si existe (disabled)
+        if (this.currentSpinner) {
+            // this.currentSpinner.fail(); // Disabled to prevent UI issues
+            this.currentSpinner = null;
+        }
+        
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.red.bold(`Operation failed!`));
+        
+        if (error) {
+            console.log(chalk.red(`   ${error}`));
+        }
+        
+        console.log('');
+        
+        return this;
+    }
+
+    /**
+     * Crea una barra de progreso visual
+     */
+    createProgressBar() {
+        if (this.totalSteps === 0) return '';
+        
+        const percentage = (this.currentStep / this.totalSteps);
+        const filledBars = Math.floor(percentage * 20);
+        const emptyBars = 20 - filledBars;
+        
+        const filled = chalk.cyan('█'.repeat(filledBars));
+        const empty = chalk.gray('░'.repeat(emptyBars));
+        
+        return `${filled}${empty} ${Math.round(percentage * 100)}%`;
+    }
+
+    /**
+     * Obtiene el tiempo transcurrido desde el inicio de la operación
+     */
+    getTotalElapsedTime() {
+        if (!this.startTime) return '0ms';
+        
+        const elapsed = Date.now() - this.startTime;
+        
+        if (elapsed < 1000) return `${elapsed}ms`;
+        if (elapsed < 60000) return `${(elapsed / 1000).toFixed(1)}s`;
+        
+        const minutes = Math.floor(elapsed / 60000);
+        const seconds = Math.floor((elapsed % 60000) / 1000);
+        return `${minutes}m ${seconds}s`;
+    }
+
+    /**
+     * Obtiene el tiempo transcurrido desde el último paso
+     */
+    getElapsedTime() {
+        if (this.stepTimes.length === 0) return '0ms';
+        
+        const lastStepTime = this.stepTimes[this.stepTimes.length - 1];
+        const elapsed = Date.now() - lastStepTime;
+        
+        if (elapsed < 1000) return `${elapsed}ms`;
+        return `${(elapsed / 1000).toFixed(1)}s`;
+    }
+
+    /**
+     * Obtiene el tiempo transcurrido desde el inicio del paso actual
+     */
+    getStepElapsedTime() {
+        if (!this.stepStartTime) return '0ms';
+        
+        const elapsed = Date.now() - this.stepStartTime;
+        
+        if (elapsed < 1000) return `${elapsed}ms`;
+        return `${(elapsed / 1000).toFixed(1)}s`;
+    }
+
+    /**
+     * Método estático para crear una instancia rápida
+     */
+    static create(enabled = true) {
+        return new VerboseProgress(enabled);
+    }
+}
+
+module.exports = VerboseProgress;