llm-checker 3.5.2 → 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 {
@@ -65,6 +66,7 @@ const COMMAND_HEADER_LABELS = {
     demo: 'Demo',
     ollama: 'Ollama Integration',
     recommend: 'Recommendations',
+    simulate: 'Hardware Simulation',
     'list-models': 'Model Catalog'
 };
 
@@ -1202,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;
@@ -1219,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('│'));
     }
 
@@ -1241,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('│'));
     });
@@ -2078,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)}`);
@@ -2938,6 +2946,11 @@ program
     .option('--performance-test', 'Run performance benchmarks')
     .option('--show-ollama-analysis', 'Show detailed Ollama model analysis')
     .option('--no-verbose', 'Disable step-by-step progress display')
+    .option('--simulate <profile>', 'Simulate a hardware profile instead of detecting real hardware (use "list" to see profiles)')
+    .option('--gpu <model>', 'Custom GPU model for simulation (e.g., "RTX 5060", "RX 7800 XT")')
+    .option('--ram <gb>', 'Custom RAM in GB for simulation (e.g., 32)')
+    .option('--cpu <model>', 'Custom CPU model for simulation (e.g., "AMD Ryzen 7 5700X")')
+    .option('--vram <gb>', 'Override GPU VRAM in GB for simulation (auto-detected if omitted)')
     .addHelpText(
         'after',
         `
@@ -2946,6 +2959,12 @@ Enterprise policy examples:
   $ llm-checker check --policy ./policy.yaml --use-case coding --runtime vllm
   $ llm-checker check --policy ./policy.yaml --include-cloud --max-size 24B
 
+Hardware simulation:
+  $ llm-checker check --simulate list
+  $ llm-checker check --simulate rtx4090
+  $ llm-checker check --simulate m4pro24 --use-case coding
+  $ llm-checker check --gpu "RTX 5060" --ram 32 --cpu "AMD Ryzen 7 5700X"
+
 Policy scope:
   - Evaluates all compatible and marginal candidates discovered during analysis
   - Not limited to the top --limit results shown in output
@@ -2958,7 +2977,57 @@ Policy scope:
             const verboseEnabled = options.verbose !== false;
             const checker = new (getLLMChecker())({ verbose: verboseEnabled });
             const policyConfig = options.policy ? loadPolicyConfiguration(options.policy) : null;
-            
+
+            // Handle hardware simulation (preset profile or custom flags)
+            const hasCustomHwFlags = options.gpu || options.ram || options.cpu || options.vram;
+            if (options.simulate || hasCustomHwFlags) {
+                const { buildFullHardwareObject, buildCustomHardwareObject, getProfile, listProfiles } = require('../src/hardware/profiles');
+                if (options.simulate === 'list') {
+                    console.log(chalk.cyan.bold('\n  Available Hardware Profiles:\n'));
+                    listProfiles().forEach(line => console.log(line));
+                    console.log('');
+                    return;
+                }
+                let simulatedHardware;
+                let displayLabel;
+                if (hasCustomHwFlags) {
+                    const ramValue = options.ram ? parseInt(options.ram) : undefined;
+                    const vramValue = options.vram ? parseInt(options.vram) : undefined;
+                    if (options.vram && !options.gpu) {
+                        console.error(chalk.red('\n  --vram requires --gpu in custom hardware mode (e.g., --gpu "RTX 4090" --vram 24).'));
+                        process.exit(1);
+                    }
+                    if (options.ram && (!Number.isFinite(ramValue) || ramValue <= 0)) {
+                        console.error(chalk.red(`\n  Invalid --ram value: "${options.ram}". Must be a positive number (e.g., 32).`));
+                        process.exit(1);
+                    }
+                    if (options.vram && (!Number.isFinite(vramValue) || vramValue <= 0)) {
+                        console.error(chalk.red(`\n  Invalid --vram value: "${options.vram}". Must be a positive number (e.g., 8).`));
+                        process.exit(1);
+                    }
+                    simulatedHardware = buildCustomHardwareObject({
+                        gpu: options.gpu || null,
+                        ram: ramValue,
+                        cpu: options.cpu || null,
+                        vram: vramValue
+                    });
+                    displayLabel = simulatedHardware._displayName;
+                } else {
+                    const profile = getProfile(options.simulate);
+                    if (!profile) {
+                        console.error(chalk.red(`\n  Unknown profile: ${options.simulate}`));
+                        console.log(chalk.gray('\n  Available profiles:'));
+                        listProfiles().forEach(line => console.log(line));
+                        console.log('');
+                        process.exit(1);
+                    }
+                    simulatedHardware = buildFullHardwareObject(options.simulate);
+                    displayLabel = profile.displayName;
+                }
+                checker.setSimulatedHardware(simulatedHardware);
+                console.log(chalk.magenta.bold(`\n  SIMULATION MODE: ${displayLabel}\n`));
+            }
+
             // If verbose is disabled, show simple loading message
             if (!verboseEnabled) {
                 process.stdout.write(chalk.gray('Analyzing your system...'));
@@ -3429,6 +3498,11 @@ program
     .option('--optimize <profile>', 'Optimization profile (balanced|speed|quality|context|coding)', 'balanced')
     .option('--no-verbose', 'Disable step-by-step progress display')
     .option('--policy <file>', 'Evaluate recommendations against a policy file')
+    .option('--simulate <profile>', 'Simulate a hardware profile instead of detecting real hardware (use "list" to see profiles)')
+    .option('--gpu <model>', 'Custom GPU model for simulation (e.g., "RTX 5060", "RX 7800 XT")')
+    .option('--ram <gb>', 'Custom RAM in GB for simulation (e.g., 32)')
+    .option('--cpu <model>', 'Custom CPU model for simulation (e.g., "AMD Ryzen 7 5700X")')
+    .option('--vram <gb>', 'Override GPU VRAM in GB for simulation (auto-detected if omitted)')
     .option(
         '--calibrated [file]',
         'Use calibrated routing policy (optional file path; defaults to ~/.llm-checker/calibration-policy.{yaml,yml,json})'
@@ -3441,6 +3515,11 @@ Enterprise policy examples:
   $ llm-checker recommend --policy ./policy.yaml --category coding
   $ llm-checker recommend --policy ./policy.yaml --no-verbose
 
+Hardware simulation:
+  $ llm-checker recommend --simulate rtx4090
+  $ llm-checker recommend --simulate m4pro24 --category coding
+  $ llm-checker recommend --gpu "RTX 5060" --ram 32 --cpu "AMD Ryzen 7 5700X"
+
 Calibrated routing examples:
   $ llm-checker recommend --calibrated --category coding
   $ llm-checker recommend --calibrated ./calibration-policy.yaml --category reasoning
@@ -3452,6 +3531,57 @@ Calibrated routing examples:
         try {
             const verboseEnabled = options.verbose !== false;
             const checker = new (getLLMChecker())({ verbose: verboseEnabled });
+
+            // Handle hardware simulation (preset profile or custom flags)
+            const hasCustomHwFlags = options.gpu || options.ram || options.cpu || options.vram;
+            if (options.simulate || hasCustomHwFlags) {
+                const { buildFullHardwareObject, buildCustomHardwareObject, getProfile, listProfiles } = require('../src/hardware/profiles');
+                if (options.simulate === 'list') {
+                    console.log(chalk.cyan.bold('\n  Available Hardware Profiles:\n'));
+                    listProfiles().forEach(line => console.log(line));
+                    console.log('');
+                    return;
+                }
+                let simulatedHardware;
+                let displayLabel;
+                if (hasCustomHwFlags) {
+                    const ramValue = options.ram ? parseInt(options.ram) : undefined;
+                    const vramValue = options.vram ? parseInt(options.vram) : undefined;
+                    if (options.vram && !options.gpu) {
+                        console.error(chalk.red('\n  --vram requires --gpu in custom hardware mode (e.g., --gpu "RTX 4090" --vram 24).'));
+                        process.exit(1);
+                    }
+                    if (options.ram && (!Number.isFinite(ramValue) || ramValue <= 0)) {
+                        console.error(chalk.red(`\n  Invalid --ram value: "${options.ram}". Must be a positive number (e.g., 32).`));
+                        process.exit(1);
+                    }
+                    if (options.vram && (!Number.isFinite(vramValue) || vramValue <= 0)) {
+                        console.error(chalk.red(`\n  Invalid --vram value: "${options.vram}". Must be a positive number (e.g., 8).`));
+                        process.exit(1);
+                    }
+                    simulatedHardware = buildCustomHardwareObject({
+                        gpu: options.gpu || null,
+                        ram: ramValue,
+                        cpu: options.cpu || null,
+                        vram: vramValue
+                    });
+                    displayLabel = simulatedHardware._displayName;
+                } else {
+                    const profile = getProfile(options.simulate);
+                    if (!profile) {
+                        console.error(chalk.red(`\n  Unknown profile: ${options.simulate}`));
+                        console.log(chalk.gray('\n  Available profiles:'));
+                        listProfiles().forEach(line => console.log(line));
+                        console.log('');
+                        process.exit(1);
+                    }
+                    simulatedHardware = buildFullHardwareObject(options.simulate);
+                    displayLabel = profile.displayName;
+                }
+                checker.setSimulatedHardware(simulatedHardware);
+                console.log(chalk.magenta.bold(`\n  SIMULATION MODE: ${displayLabel}\n`));
+            }
+
             const routingPreference = resolveRoutingPolicyPreference({
                 policyOption: options.policy,
                 calibratedOption: options.calibrated,
@@ -3505,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) {
@@ -3524,6 +3654,191 @@ Calibrated routing examples:
         }
     });
 
+program
+    .command('simulate')
+    .description('Simulate hardware profiles to see compatible LLM models for different systems')
+    .option('-p, --profile <name>', 'Hardware profile to simulate (e.g., rtx4090, m4pro24, h100)')
+    .option('-l, --list', 'List all available hardware profiles')
+    .option('--gpu <model>', 'Custom GPU model (e.g., "RTX 5060", "RX 7800 XT", "Apple M4 Pro")')
+    .option('--ram <gb>', 'Custom RAM in GB (e.g., 32)')
+    .option('--cpu <model>', 'Custom CPU model (e.g., "AMD Ryzen 7 5700X")')
+    .option('--vram <gb>', 'Override GPU VRAM in GB (auto-detected from GPU model if omitted)')
+    .option('-u, --use-case <case>', 'Specify use case', 'general')
+    .option('--optimize <profile>', 'Optimization profile (balanced|speed|quality|context|coding)', 'balanced')
+    .option('--limit <number>', 'Number of compatible models to show (default: 1)', '1')
+    .option('--no-verbose', 'Disable step-by-step progress display')
+    .addHelpText(
+        'after',
+        `
+Preset profiles:
+  $ llm-checker simulate --list
+  $ llm-checker simulate
+  $ llm-checker simulate -p rtx4090
+  $ llm-checker simulate -p m4pro24 --use-case coding
+
+Custom hardware:
+  $ llm-checker simulate --gpu "RTX 5060" --ram 32 --cpu "AMD Ryzen 7 5700X"
+  $ llm-checker simulate --gpu "RTX 4090" --ram 64
+  $ llm-checker simulate --gpu "RX 7800 XT" --ram 32 --vram 16
+  $ llm-checker simulate --ram 16
+`
+    )
+    .action(async (options) => {
+        const { buildFullHardwareObject, buildCustomHardwareObject, getProfile, getProfilesByCategory, listProfiles, CATEGORY_LABELS } = require('../src/hardware/profiles');
+
+        // List mode
+        if (options.list) {
+            console.log(chalk.cyan.bold('\n  Available Hardware Profiles:\n'));
+            listProfiles().forEach(line => console.log(line));
+            console.log('');
+            return;
+        }
+
+        let simulatedHardware;
+        let displayLabel;
+
+        // Custom hardware mode: --gpu, --ram, --cpu, --vram
+        const hasCustomFlags = options.gpu || options.ram || options.cpu || options.vram;
+        if (hasCustomFlags) {
+            const ramValue = options.ram ? parseInt(options.ram) : undefined;
+            const vramValue = options.vram ? parseInt(options.vram) : undefined;
+            if (options.vram && !options.gpu) {
+                console.error(chalk.red('\n  --vram requires --gpu in custom hardware mode (e.g., --gpu "RTX 4090" --vram 24).'));
+                process.exit(1);
+            }
+            if (options.ram && (!Number.isFinite(ramValue) || ramValue <= 0)) {
+                console.error(chalk.red(`\n  Invalid --ram value: "${options.ram}". Must be a positive number (e.g., 32).`));
+                process.exit(1);
+            }
+            if (options.vram && (!Number.isFinite(vramValue) || vramValue <= 0)) {
+                console.error(chalk.red(`\n  Invalid --vram value: "${options.vram}". Must be a positive number (e.g., 8).`));
+                process.exit(1);
+            }
+            simulatedHardware = buildCustomHardwareObject({
+                gpu: options.gpu || null,
+                ram: ramValue,
+                cpu: options.cpu || null,
+                vram: vramValue
+            });
+            displayLabel = simulatedHardware._displayName;
+        } else {
+            // Preset profile mode
+            if (!options.profile) {
+                // Guard against non-interactive environments
+                if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                    console.error(chalk.red('\n  No hardware profile specified.'));
+                    console.log(chalk.gray('  Use --profile <name>, --gpu/--ram/--cpu flags, or --list to see profiles.\n'));
+                    process.exit(1);
+                }
+                // Interactive selection
+                try {
+                    const inquirer = require('inquirer');
+                    const categories = getProfilesByCategory();
+                    const choices = [];
+
+                    for (const [category, profiles] of Object.entries(categories)) {
+                        const label = CATEGORY_LABELS[category] || category;
+                        choices.push(new inquirer.Separator(chalk.gray(`── ${label} ──`)));
+                        for (const [key, profile] of Object.entries(profiles)) {
+                            const vramLabel = profile.gpu.unified
+                                ? `${profile.memory.total}GB unified`
+                                : (profile.gpu.vram > 0 ? `${profile.gpu.vram}GB VRAM` : 'No GPU');
+                            const ramLabel = profile.gpu.unified ? '' : ` / ${profile.memory.total}GB RAM`;
+                            choices.push({
+                                name: `${profile.displayName}  ${chalk.gray(`(${vramLabel}${ramLabel})`)}`,
+                                value: key
+                            });
+                        }
+                    }
+
+                    const { selectedProfile } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selectedProfile',
+                        message: 'Select a hardware profile to simulate:',
+                        choices,
+                        pageSize: 20
+                    }]);
+                    options.profile = selectedProfile;
+                } catch (error) {
+                    if (error.isTtyError) {
+                        console.error(chalk.red('Interactive mode requires a TTY terminal.'));
+                        console.log(chalk.gray('Use --profile <name>, --gpu/--ram flags, or --list to see available profiles.'));
+                        process.exit(1);
+                    }
+                    throw error;
+                }
+            }
+
+            // Validate profile
+            const profile = getProfile(options.profile);
+            if (!profile) {
+                console.error(chalk.red(`\n  Unknown profile: ${options.profile}`));
+                console.log(chalk.gray('\n  Available profiles:'));
+                listProfiles().forEach(line => console.log(line));
+                console.log('');
+                process.exit(1);
+            }
+
+            simulatedHardware = buildFullHardwareObject(options.profile);
+            displayLabel = profile.displayName;
+        }
+
+        showAsciiArt('simulate');
+
+        try {
+            const verboseEnabled = options.verbose !== false;
+            const checker = new (getLLMChecker())({ verbose: verboseEnabled });
+            checker.setSimulatedHardware(simulatedHardware);
+
+            console.log(chalk.magenta.bold(`  SIMULATION MODE: ${displayLabel}\n`));
+
+            if (!verboseEnabled) {
+                process.stdout.write(chalk.gray('Analyzing simulated hardware...'));
+            }
+
+            const hardware = await checker.getSystemInfo();
+
+            const normalizeUseCase = (useCase = '') => {
+                const alias = useCase.toLowerCase().trim();
+                const useCaseMap = {
+                    'embed': 'embeddings', 'embedding': 'embeddings', 'embeddings': 'embeddings',
+                    'embedings': 'embeddings', 'talk': 'chat', 'chat': 'chat', 'talking': 'chat'
+                };
+                return useCaseMap[alias] || alias || 'general';
+            };
+
+            const analysis = await checker.analyze({
+                useCase: normalizeUseCase(options.useCase),
+                limit: parseInt(options.limit) || 10,
+                runtime: 'ollama'
+            });
+
+            if (!verboseEnabled) {
+                console.log(chalk.green(' done'));
+            }
+
+            displaySimplifiedSystemInfo(hardware);
+
+            const normalizedUseCase = normalizeUseCase(options.useCase);
+            const limit = parseInt(options.limit) || 1;
+            const recommendedModels = await displayModelRecommendations(
+                analysis,
+                hardware,
+                normalizedUseCase,
+                limit,
+                'ollama'
+            );
+            await displayQuickStartCommands(analysis, recommendedModels[0], recommendedModels, 'ollama');
+
+        } catch (error) {
+            console.error(chalk.red('\nError:'), error.message);
+            if (process.env.DEBUG) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    });
+
 program
     .command('list-models')
     .description('List all models from Ollama database')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.2",
+  "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",
@@ -47,7 +47,7 @@
     "inquirer": "^8.2.6",
     "node-fetch": "^2.7.0",
     "ora": "^5.4.1",
-    "systeminformation": "^5.21.0",
+    "systeminformation": "^5.31.1",
     "table": "^6.8.1",
     "yaml": "^2.8.1",
     "zod": "^3.23.0"
@@ -55,9 +55,16 @@
   "optionalDependencies": {
     "sql.js": "^1.14.0"
   },
+  "overrides": {
+    "ajv": "^8.18.0",
+    "hono": "^4.11.10",
+    "glob": "^13.0.0",
+    "minimatch": "^10.2.2",
+    "test-exclude": "^7.0.1"
+  },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "jest": "^29.7.0"
+    "jest": "^30.2.0"
   },
   "keywords": [
     "llm",

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

@@ -7,9 +7,22 @@ class HardwareDetector {
         this.cacheExpiry = 5 * 60 * 1000;
         this.cacheTime = 0;
         this.unifiedDetector = new UnifiedDetector();
+        this._simulatedHardware = null;
+    }
+
+    setSimulatedHardware(hardwareObject) {
+        this._simulatedHardware = hardwareObject;
+    }
+
+    clearSimulatedHardware() {
+        this._simulatedHardware = null;
     }
 
     async getSystemInfo(forceFresh = false) {
+        // Return simulated hardware if set (bypasses real detection)
+        if (this._simulatedHardware) {
+            return this._simulatedHardware;
+        }
 
         if (!forceFresh && this.cache && (Date.now() - this.cacheTime < this.cacheExpiry)) {
             return this.cache;
@@ -242,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 = {
@@ -264,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) {