llm-checker 3.5.3 → 3.5.4

package/README.md

@@ -531,19 +531,24 @@ Hardware Tier: HIGH | Models Analyzed: 205
 Coding:
    qwen2.5-coder:14b (14B)
    Score: 78/100
+   Fine-tuning: LoRA+QLoRA
    Command: ollama pull qwen2.5-coder:14b
 
 Reasoning:
    deepseek-r1:14b (14B)
    Score: 86/100
+   Fine-tuning: QLoRA
    Command: ollama pull deepseek-r1:14b
 
 Multimodal:
    llama3.2-vision:11b (11B)
    Score: 83/100
+   Fine-tuning: LoRA+QLoRA
    Command: ollama pull llama3.2-vision:11b
 ```
 
+`check`, `recommend`, and `ai-check` include a fine-tuning suitability label in output to help choose between Full FT, LoRA, and QLoRA paths.
+
 ### `search` — Model Search
 
 ```bash

package/bin/enhanced_cli.js

@@ -23,6 +23,7 @@ const {
     getRuntimeDisplayName,
     getRuntimeCommandSet
 } = require('../src/runtime/runtime-support');
+const { evaluateFineTuningSupport } = require('../src/models/fine-tuning-support');
 const { CalibrationManager } = require('../src/calibration/calibration-manager');
 const { SUPPORTED_CALIBRATION_OBJECTIVES } = require('../src/calibration/schemas');
 const {
@@ -1203,7 +1204,7 @@ function displayLegacyRecommendations(recommendations) {
     console.log(chalk.cyan('╰'));
 }
 
-function displayIntelligentRecommendations(intelligentData) {
+function displayIntelligentRecommendations(intelligentData, hardware = null) {
     if (!intelligentData || !intelligentData.summary) return;
 
     const { summary, recommendations } = intelligentData;
@@ -1220,10 +1221,12 @@ function displayIntelligentRecommendations(intelligentData) {
     // Mostrar mejor modelo general
     if (summary.best_overall) {
         const best = summary.best_overall;
+        const bestFineTuning = evaluateFineTuningSupport(best, hardware || {});
         console.log(chalk.red('│') + ` ${chalk.bold.yellow('BEST OVERALL:')} ${chalk.green.bold(best.name)}`);
         console.log(chalk.red('│') + `    Command: ${chalk.cyan.bold(best.command)}`);
         console.log(chalk.red('│') + `    Score: ${chalk.yellow.bold(best.score)}/100 | Category: ${chalk.magenta(best.category)}`);
         console.log(chalk.red('│') + `    Quantization: ${chalk.white.bold(best.quantization || 'Q4_K_M')}`);
+        console.log(chalk.red('│') + `    Fine-tuning: ${chalk.blue.bold(bestFineTuning.shortLabel)}`);
         console.log(chalk.red('│'));
     }
 
@@ -1242,11 +1245,13 @@ function displayIntelligentRecommendations(intelligentData) {
         const icon = categories[category] || 'Other';
         const categoryName = category.charAt(0).toUpperCase() + category.slice(1);
         const scoreColor = getScoreColor(model.score);
+        const fineTuningSupport = evaluateFineTuningSupport(model, hardware || {});
         
         console.log(chalk.red('│') + ` ${chalk.bold.white(categoryName)} (${icon}):`);
         console.log(chalk.red('│') + `    ${chalk.green(model.name)} (${model.size})`);
         console.log(chalk.red('│') + `    Score: ${scoreColor.bold(model.score)}/100 | Pulls: ${chalk.gray(model.pulls?.toLocaleString() || 'N/A')}`);
         console.log(chalk.red('│') + `    Quantization: ${chalk.white.bold(model.quantization || 'Q4_K_M')}`);
+        console.log(chalk.red('│') + `    Fine-tuning: ${chalk.blue.bold(fineTuningSupport.shortLabel)}`);
         console.log(chalk.red('│') + `    Command: ${chalk.cyan.bold(model.command)}`);
         console.log(chalk.red('│'));
     });
@@ -2079,6 +2084,8 @@ async function displayModelRecommendations(analysis, hardware, useCase = 'genera
             const realSize = getRealSizeFromOllamaCache(model) || estimateModelSize(model);
             console.log(`Size: ${chalk.white(realSize)}`);
             console.log(`Compatibility Score: ${chalk.green.bold(model.adjustedScore || model.score || 'N/A')}/100`);
+            const fineTuningSupport = evaluateFineTuningSupport(model, hardware);
+            console.log(`Fine-tuning: ${chalk.blue.bold(fineTuningSupport.shortLabel)}`);
             
             if (index === 0) {
                 console.log(`Reason: ${chalk.gray(reason)}`);
@@ -3628,7 +3635,7 @@ Calibrated routing examples:
             displaySystemInfo(hardware, { summary: { hardwareTier: intelligentRecommendations.summary.hardware_tier } });
             
             // Mostrar recomendaciones
-            displayIntelligentRecommendations(intelligentRecommendations);
+            displayIntelligentRecommendations(intelligentRecommendations, hardware);
             displayCalibratedRoutingDecision('recommend', calibratedPolicy, routeDecision, routingPreference.warnings);
 
             if (policyConfig && policyEvaluation && policyEnforcement) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "Intelligent CLI tool with AI-powered model selection that analyzes your hardware and recommends optimal LLM models for your system",
   "bin": {
     "llm-checker": "bin/cli.js",

package/src/hardware/backends/rocm-detector.js

@@ -248,13 +248,20 @@ class ROCmDetector {
                 timeout: 10000
             });
 
-            // Parse memory info
-            const memMatches = memInfo.matchAll(/GPU\[(\d+)\].*?Total.*?:\s*(\d+)/g);
+            // Parse memory info. Newer rocm-smi reports bytes "(B)" while some
+            // systems expose MiB; normalize to GB safely.
             const gpuMemory = {};
-            for (const match of memMatches) {
-                const idx = parseInt(match[1]);
-                const memMB = parseInt(match[2]);
-                gpuMemory[idx] = Math.round(memMB / 1024);  // Convert to GB
+            const memLines = String(memInfo || '').split('\n');
+            for (const line of memLines) {
+                const lineMatch = line.match(/GPU\[(\d+)\].*?Total.*?Memory\s*(?:\(([^)]+)\))?\s*:\s*(\d+)/i);
+                if (!lineMatch) continue;
+
+                const idx = parseInt(lineMatch[1], 10);
+                const unitHint = lineMatch[2] || '';
+                const rawValue = parseInt(lineMatch[3], 10);
+
+                if (!Number.isFinite(rawValue) || rawValue <= 0) continue;
+                gpuMemory[idx] = this.normalizeRocmMemoryToGB(rawValue, unitHint);
             }
 
             // Get temperature and utilization
@@ -312,6 +319,45 @@ class ROCmDetector {
         }
     }
 
+    /**
+     * Normalize rocm-smi memory values to GB.
+     * rocm-smi may report bytes "(B)" or MiB depending on version/system.
+     */
+    normalizeRocmMemoryToGB(value, unitHint = '') {
+        const numericValue = Number(value);
+        if (!Number.isFinite(numericValue) || numericValue <= 0) {
+            return 0;
+        }
+
+        const unit = String(unitHint || '').toLowerCase();
+
+        if (unit.includes('gib') || unit.includes('gb')) {
+            return Math.round(numericValue);
+        }
+
+        if (unit.includes('mib') || unit.includes('mb')) {
+            return Math.round(numericValue / 1024);
+        }
+
+        if (unit.includes('kib') || unit.includes('kb')) {
+            return Math.round(numericValue / (1024 * 1024));
+        }
+
+        if (unit === 'b' || unit === 'bytes') {
+            return Math.round(numericValue / (1024 ** 3));
+        }
+
+        // Unit was not provided. Use value magnitude heuristics.
+        if (numericValue >= 1024 ** 3) {
+            return Math.round(numericValue / (1024 ** 3));
+        }
+        if (numericValue >= 1024) {
+            return Math.round(numericValue / 1024);
+        }
+
+        return Math.round(numericValue);
+    }
+
     /**
      * Detect GPUs via rocminfo
      */

package/src/hardware/detector.js

@@ -255,20 +255,43 @@ class HardwareDetector {
             }
 
             const primaryType = unified.primary.type || 'cpu';
-            if (primaryType === 'cpu') {
+            const hasFallbackDedicatedGpu = Boolean(
+                primaryType === 'cpu' &&
+                unified.systemGpu?.available &&
+                Array.isArray(unified.systemGpu.gpus) &&
+                unified.systemGpu.gpus.some((gpu) => gpu.type === 'dedicated')
+            );
+
+            if (primaryType === 'cpu' && !hasFallbackDedicatedGpu) {
                 return;
             }
 
             const summary = unified.summary;
-            const backendInfo = unified.backends?.[primaryType]?.info || {};
-            const backendGPUs = Array.isArray(backendInfo.gpus) ? backendInfo.gpus : [];
-            const gpuCount = summary.gpuCount || backendGPUs.length || systemInfo.gpu.gpuCount || 1;
+            const backendInfo = hasFallbackDedicatedGpu
+                ? unified.systemGpu
+                : (unified.backends?.[primaryType]?.info || {});
 
-            const totalVRAM = typeof summary.totalVRAM === 'number' ? summary.totalVRAM : systemInfo.gpu.vram;
-            const perGPUVRAM = backendGPUs[0]?.memory?.total
-                || (gpuCount > 0 && totalVRAM > 0 ? Math.round(totalVRAM / gpuCount) : 0);
-
-            const modelFromUnified = summary.gpuInventory || summary.gpuModel || systemInfo.gpu.model;
+            const backendGPUs = Array.isArray(backendInfo.gpus) ? backendInfo.gpus : [];
+            const dedicatedBackendGPUs = backendGPUs.filter((gpu) => gpu?.type !== 'integrated');
+
+            const gpuCount = summary.gpuCount ||
+                dedicatedBackendGPUs.length ||
+                backendGPUs.length ||
+                systemInfo.gpu.gpuCount ||
+                1;
+
+            const totalVRAMFromUnified = typeof summary.totalVRAM === 'number' ? summary.totalVRAM : 0;
+            const totalVRAMFromFallback = dedicatedBackendGPUs.reduce((sum, gpu) => {
+                const amount = Number(gpu?.memory?.total || gpu?.memoryTotal || 0);
+                return sum + (Number.isFinite(amount) ? amount : 0);
+            }, 0);
+            const totalVRAM = totalVRAMFromUnified || totalVRAMFromFallback || systemInfo.gpu.vram;
+            const perGPUVRAM = dedicatedBackendGPUs[0]?.memory?.total ||
+                backendGPUs[0]?.memory?.total ||
+                (gpuCount > 0 && totalVRAM > 0 ? Math.round(totalVRAM / gpuCount) : 0);
+
+            const fallbackModel = dedicatedBackendGPUs[0]?.name || backendGPUs[0]?.name || null;
+            const modelFromUnified = summary.gpuInventory || summary.gpuModel || fallbackModel || systemInfo.gpu.model;
             const vendor = this.inferVendorFromGPUModel(modelFromUnified, systemInfo.gpu.vendor);
 
             systemInfo.gpu = {
@@ -277,11 +300,11 @@ class HardwareDetector {
                 vendor,
                 vram: totalVRAM || systemInfo.gpu.vram,
                 vramPerGPU: perGPUVRAM || systemInfo.gpu.vramPerGPU || 0,
-                dedicated: primaryType !== 'metal',
+                dedicated: hasFallbackDedicatedGpu ? true : primaryType !== 'metal',
                 gpuCount,
                 isMultiGPU: Boolean(summary.isMultiGPU || gpuCount > 1),
                 gpuInventory: summary.gpuInventory || null,
-                backend: primaryType,
+                backend: hasFallbackDedicatedGpu ? 'generic' : primaryType,
                 driverVersion: backendInfo.driver || systemInfo.gpu.driverVersion
             };
         } catch (error) {

package/src/hardware/unified-detector.js

@@ -10,6 +10,7 @@ const ROCmDetector = require('./backends/rocm-detector');
 const IntelDetector = require('./backends/intel-detector');
 const CPUDetector = require('./backends/cpu-detector');
 const si = require('systeminformation');
+const { execSync } = require('child_process');
 
 class UnifiedDetector {
     constructor() {
@@ -363,6 +364,20 @@ class UnifiedDetector {
             })
             .filter(Boolean);
 
+        if (process.platform === 'linux') {
+            const lspciControllers = this.detectLinuxLspciGpus();
+            const knownKeys = new Set(
+                normalized.map((gpu) => this.getGpuMatchKey(gpu.name)).filter(Boolean)
+            );
+
+            for (const gpu of lspciControllers) {
+                const nameKey = this.getGpuMatchKey(gpu.name);
+                if (!nameKey || knownKeys.has(nameKey)) continue;
+                normalized.push(gpu);
+                knownKeys.add(nameKey);
+            }
+        }
+
         if (normalized.length === 0) {
             return {
                 available: false,
@@ -381,7 +396,7 @@ class UnifiedDetector {
 
         return {
             available: true,
-            source: 'systeminformation',
+            source: process.platform === 'linux' ? 'systeminformation+lspci' : 'systeminformation',
             gpus: normalized,
             totalVRAM,
             isMultiGPU: dedicated.length > 1,
@@ -389,6 +404,66 @@ class UnifiedDetector {
         };
     }
 
+    detectLinuxLspciGpus() {
+        try {
+            const lspciOutput = execSync('lspci -nn | grep -Ei "VGA|3D|Display"', {
+                encoding: 'utf8',
+                timeout: 8000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            return this.parseLinuxLspciGpus(lspciOutput);
+        } catch (error) {
+            return [];
+        }
+    }
+
+    parseLinuxLspciGpus(lspciOutput = '') {
+        const lines = String(lspciOutput || '')
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+
+        const results = [];
+        const seen = new Set();
+
+        for (const line of lines) {
+            const lineLower = line.toLowerCase();
+            const isNvidia = lineLower.includes('nvidia');
+            const isAMD = lineLower.includes('amd') || lineLower.includes('ati') || lineLower.includes('radeon');
+            const isIntel = lineLower.includes('intel');
+
+            if (!isNvidia && !isAMD && !isIntel) continue;
+
+            const genericName = line
+                .replace(/^[0-9a-f:.]+\s+/i, '')
+                .replace(/\(rev\s+[0-9a-f]+\)$/i, '')
+                .trim();
+
+            const bracketName = line.match(/\[(?![0-9a-f]{4}:[0-9a-f]{4}\])([^\]]+)\]\s*\[[0-9a-f]{4}:[0-9a-f]{4}\]/i);
+            const name = (bracketName?.[1] || genericName || 'Unknown GPU').replace(/\s+/g, ' ').trim();
+            if (!name || name.toLowerCase() === 'unknown gpu') continue;
+
+            const isIntegrated = this.isIntegratedGPUModel(name) || isIntel;
+            let vram = this.estimateFallbackVRAM(name);
+            if (isIntegrated) {
+                vram = 0;
+            }
+
+            const dedupeKey = `${name.toLowerCase()}|${isIntegrated ? 'i' : 'd'}`;
+            if (seen.has(dedupeKey)) continue;
+            seen.add(dedupeKey);
+
+            results.push({
+                name,
+                vendor: isNvidia ? 'NVIDIA' : (isAMD ? 'AMD' : 'Intel'),
+                type: isIntegrated ? 'integrated' : 'dedicated',
+                memory: { total: vram }
+            });
+        }
+
+        return results;
+    }
+
     normalizeFallbackVRAM(value) {
         const num = Number(value);
         if (!Number.isFinite(num) || num <= 0) return 0;
@@ -426,6 +501,7 @@ class UnifiedDetector {
             lower.includes('iris') ||
             lower.includes('uhd') ||
             lower.includes('hd graphics') ||
+            (lower.includes('radeon') && !lower.includes('radeon rx') && /\b\d{3,4}m\b/.test(lower)) ||
             lower.includes('radeon graphics') ||
             lower.includes('radeon(tm) graphics') ||
             lower.includes('vega') ||
@@ -454,6 +530,23 @@ class UnifiedDetector {
         return 0;
     }
 
+    getGpuMatchKey(name) {
+        const lower = String(name || '').toLowerCase();
+        if (!lower) return '';
+
+        const familyMatch = lower.match(/\b(rtx|gtx|rx|arc)\s*([0-9]{3,4})\b/);
+        if (familyMatch) {
+            return `${familyMatch[1]}${familyMatch[2]}`;
+        }
+
+        const concise = lower
+            .replace(/nvidia|amd|ati|intel|corporation|geforce|radeon|graphics/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+
+        return concise || lower;
+    }
+
     /**
      * Generate hardware fingerprint for benchmarks
      */

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

@@ -11,6 +11,7 @@ const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const fetch = require('../utils/fetch');
+const { evaluateFineTuningSupport } = require('./fine-tuning-support');
 
 class AICheckSelector {
     constructor() {
@@ -606,6 +607,7 @@ Return JSON with this structure:
                 chalk.bgMagenta.white.bold(' Det Score '),
                 chalk.bgMagenta.white.bold(' AI Score '),
                 chalk.bgMagenta.white.bold(' Final '),
+                chalk.bgMagenta.white.bold(' Fine-tune '),
                 chalk.bgMagenta.white.bold(' RAM '),
                 chalk.bgMagenta.white.bold(' Speed '),
                 chalk.bgMagenta.white.bold(' Status ')
@@ -621,6 +623,7 @@ Return JSON with this structure:
             const finalScore = `${Math.round(candidate.finalScore)}/100`;
             const ram = `${candidate.requiredGB}/${Math.round(results.hardware.usableMemGB)}GB`;
             const speed = `${candidate.estTPS.toFixed(0)}t/s`;
+            const fineTuningSupport = evaluateFineTuningSupport(candidate, results.hardware || {});
             
             let statusDisplay, modelDisplay;
             if (isInstalled) {
@@ -637,6 +640,7 @@ Return JSON with this structure:
                 this.getScoreColor(candidate.score)(detScore),
                 candidate.aiScore ? this.getScoreColor(candidate.aiScore)(aiScore) : chalk.gray(aiScore),
                 this.getScoreColor(candidate.finalScore)(finalScore),
+                fineTuningSupport.shortLabel,
                 ram,
                 speed,
                 statusDisplay
@@ -648,11 +652,13 @@ Return JSON with this structure:
 
         // Best recommendation section
         const best = results.candidates[0];
+        const bestFineTuning = evaluateFineTuningSupport(best, results.hardware || {});
         console.log('\n' + chalk.bgGreen.black.bold(' AI-POWERED RECOMMENDATION '));
         console.log(chalk.green('╭' + '─'.repeat(50)));
         console.log(chalk.green('│') + ` Best Model: ${chalk.cyan.bold(best.meta.name || best.meta.model_identifier)}`);
         console.log(chalk.green('│') + ` Final Score: ${this.getScoreColor(best.finalScore)(Math.round(best.finalScore) + '/100')}`);
         console.log(chalk.green('│') + ` ⚖️  Det: ${Math.round(best.score)} + AI: ${best.aiScore ? Math.round(best.aiScore) : 'N/A'}`);
+        console.log(chalk.green('│') + ` Fine-tuning: ${chalk.blue.bold(bestFineTuning.shortLabel)}`);
         console.log(chalk.green('│'));
         
         if (best.meta.installed) {

package/src/models/fine-tuning-support.js

@@ -0,0 +1,215 @@
+/**
+ * Fine-tuning suitability helper.
+ * Provides a simple hardware-aware estimate for Full FT / LoRA / QLoRA.
+ */
+
+function toNumber(value) {
+    const num = Number(value);
+    return Number.isFinite(num) ? num : 0;
+}
+
+function parseModelParamsB(model = {}) {
+    const directParams = toNumber(model?.paramsB || model?.meta?.paramsB);
+    if (directParams > 0) return directParams;
+
+    const candidates = [
+        model?.size,
+        model?.model_identifier,
+        model?.identifier,
+        model?.name,
+        model?.meta?.model_identifier,
+        model?.meta?.name
+    ];
+
+    for (const candidate of candidates) {
+        const text = String(candidate || '');
+        if (!text) continue;
+
+        const billionMatch = text.match(/(\d+\.?\d*)\s*[bB]\b/);
+        if (billionMatch) {
+            return toNumber(billionMatch[1]);
+        }
+
+        const millionMatch = text.match(/(\d+\.?\d*)\s*[mM]\b/);
+        if (millionMatch) {
+            return toNumber(millionMatch[1]) / 1000;
+        }
+
+        const gbMatch = text.match(/(\d+\.?\d*)\s*[gG][bB]\b/);
+        if (gbMatch) {
+            // Q4-style rule-of-thumb: ~0.5GB per 1B params.
+            return toNumber(gbMatch[1]) / 0.5;
+        }
+    }
+
+    const reqRam = toNumber(model?.requirements?.ram);
+    if (reqRam > 0) {
+        // Heuristic fallback: many model entries use ~1.2-1.5x RAM multiplier.
+        return Math.max(0, reqRam / 1.5);
+    }
+
+    return 0;
+}
+
+function getHardwareBudgetGB(hardware = {}) {
+    const totalRam = toNumber(
+        hardware?.memory?.total ||
+        hardware?.memory?.totalGB ||
+        hardware?.summary?.systemRAM ||
+        hardware?.systemRAM
+    );
+    const totalVram = toNumber(
+        hardware?.gpu?.vram ||
+        hardware?.gpu?.vramGB ||
+        hardware?.summary?.totalVRAM ||
+        hardware?.totalVRAM
+    );
+
+    const gpuType = String(hardware?.gpu?.type || '').toLowerCase();
+    const gpuModel = String(hardware?.gpu?.model || '').toLowerCase();
+    const supportsMetal = Boolean(hardware?.acceleration?.supports_metal);
+
+    const isAppleUnified = supportsMetal ||
+        gpuType.includes('apple') ||
+        gpuModel.includes('apple') ||
+        /\bm[1-4]\b/.test(gpuModel);
+
+    const hasDedicatedLikeGpu = Boolean(
+        hardware?.gpu?.dedicated ||
+        totalVram > 0 ||
+        gpuType.includes('nvidia') ||
+        gpuType.includes('amd')
+    );
+
+    if (hasDedicatedLikeGpu && totalVram > 0) {
+        return {
+            budgetGB: totalVram,
+            accelerator: 'gpu'
+        };
+    }
+
+    if (isAppleUnified && totalRam > 0) {
+        // Keep headroom for OS and background apps.
+        return {
+            budgetGB: Math.max(0, Math.floor(totalRam * 0.7)),
+            accelerator: 'unified'
+        };
+    }
+
+    return {
+        budgetGB: 0,
+        accelerator: 'none'
+    };
+}
+
+function estimateFineTuningMemoryGB(paramsB) {
+    // Coarse practical estimates for local fine-tuning workflows.
+    return {
+        fullFineTuning: Math.ceil(paramsB * 8 + 4),
+        lora: Math.ceil(paramsB * 1.8 + 3),
+        qlora: Math.ceil(paramsB * 0.8 + 2)
+    };
+}
+
+function evaluateFineTuningSupport(model = {}, hardware = {}) {
+    const paramsB = parseModelParamsB(model);
+    if (paramsB <= 0) {
+        return {
+            method: 'unknown',
+            label: 'Unknown',
+            shortLabel: 'Unknown',
+            supports: {
+                fullFineTuning: false,
+                lora: false,
+                qlora: false
+            },
+            requirementsGB: {
+                fullFineTuning: 0,
+                lora: 0,
+                qlora: 0
+            },
+            paramsB: 0,
+            budgetGB: 0,
+            accelerator: 'none'
+        };
+    }
+
+    const { budgetGB, accelerator } = getHardwareBudgetGB(hardware);
+    const requirementsGB = estimateFineTuningMemoryGB(paramsB);
+
+    const canFull = budgetGB >= requirementsGB.fullFineTuning;
+    const canLoRA = budgetGB >= requirementsGB.lora;
+    const canQLoRA = budgetGB >= requirementsGB.qlora;
+
+    if (canFull) {
+        return {
+            method: 'full_ft',
+            label: 'Full FT / LoRA / QLoRA',
+            shortLabel: 'Full+LoRA+QLoRA',
+            supports: {
+                fullFineTuning: true,
+                lora: true,
+                qlora: true
+            },
+            requirementsGB,
+            paramsB,
+            budgetGB,
+            accelerator
+        };
+    }
+
+    if (canLoRA) {
+        return {
+            method: 'lora',
+            label: 'LoRA / QLoRA',
+            shortLabel: 'LoRA+QLoRA',
+            supports: {
+                fullFineTuning: false,
+                lora: true,
+                qlora: true
+            },
+            requirementsGB,
+            paramsB,
+            budgetGB,
+            accelerator
+        };
+    }
+
+    if (canQLoRA) {
+        return {
+            method: 'qlora',
+            label: 'QLoRA only',
+            shortLabel: 'QLoRA',
+            supports: {
+                fullFineTuning: false,
+                lora: false,
+                qlora: true
+            },
+            requirementsGB,
+            paramsB,
+            budgetGB,
+            accelerator
+        };
+    }
+
+    return {
+        method: 'none',
+        label: accelerator === 'none' ? 'No accelerator' : 'Not suitable',
+        shortLabel: accelerator === 'none' ? 'No accel' : 'No FT',
+        supports: {
+            fullFineTuning: false,
+            lora: false,
+            qlora: false
+        },
+        requirementsGB,
+        paramsB,
+        budgetGB,
+        accelerator
+    };
+}
+
+module.exports = {
+    parseModelParamsB,
+    estimateFineTuningMemoryGB,
+    evaluateFineTuningSupport
+};