llm-checker 3.5.4 → 3.5.7

package/README.md

@@ -40,7 +40,7 @@ Choosing the right LLM for your hardware is complex. With thousands of model var
 |:---:|---|---|
 | **200+** | Dynamic Model Pool | Uses full scraped Ollama catalog/variants when available (with curated fallback) |
 | **4D** | Scoring Engine | Quality, Speed, Fit, Context — weighted by use case |
-| **Multi-GPU** | Hardware Detection | Apple Silicon, NVIDIA CUDA, AMD ROCm, Intel Arc, CPU |
+| **Multi-GPU** | Hardware Detection | Apple Silicon, NVIDIA CUDA, AMD ROCm, Intel Arc, CPU, integrated/dedicated inventory visibility |
 | **Calibrated** | Memory Estimation | Bytes-per-parameter formula validated against real Ollama sizes |
 | **Zero** | Native Dependencies | Pure JavaScript — works on any Node.js 16+ system |
 | **Optional** | SQLite Search | Install `sql.js` to unlock `sync`, `search`, and `smart-recommend` |
@@ -82,6 +82,13 @@ npm install -g llm-checker
 npx llm-checker hw-detect
 ```
 
+**Termux (Android):**
+```bash
+pkg update
+pkg install ollama
+npm install -g llm-checker
+```
+
 **Requirements:**
 - Node.js 16+ (any version: 16, 18, 20, 22, 24)
 - [Ollama](https://ollama.ai) installed for running models
@@ -508,6 +515,16 @@ Metal:
   Memory Bandwidth: 273GB/s
 ```
 
+On hybrid or integrated-only systems, `hw-detect` now also surfaces GPU topology explicitly:
+
+```
+Dedicated GPUs: NVIDIA GeForce RTX 4060
+Integrated GPUs: Intel Iris Xe Graphics
+Assist path: Integrated/shared-memory GPU detected, runtime remains CPU
+```
+
+This makes integrated GPUs visible even when the selected runtime backend is still CPU.
+
 ### `recommend` — Category Recommendations
 
 ```bash

package/bin/enhanced_cli.js

@@ -16,6 +16,7 @@ function getLLMChecker() {
 const { getLogger } = require('../src/utils/logger');
 const fs = require('fs');
 const path = require('path');
+const { normalizePlatform, isTermuxEnvironment } = require('../src/utils/platform');
 const {
     SUPPORTED_RUNTIMES,
     normalizeRuntime,
@@ -513,8 +514,23 @@ if (!program.commands.some((cmd) => cmd.name() === 'help')) {
 
 // Ollama installation helper
 function getOllamaInstallInstructions() {
-    const platform = os.platform();
+    const rawPlatform = os.platform();
+    const platform = normalizePlatform(rawPlatform);
     const arch = os.arch();
+
+    if (isTermuxEnvironment(rawPlatform, process.env)) {
+        return {
+            name: `Termux (Android${arch ? ` ${arch}` : ''})`,
+            downloadUrl: 'https://github.com/termux/termux-packages',
+            instructions: [
+                '1. Update Termux packages: pkg update',
+                '2. Install Ollama from the Termux repository: pkg install ollama',
+                '3. Start Ollama in the current shell: ollama serve',
+                '4. In a new Termux session, test with: ollama run llama3.2:1b'
+            ],
+            alternativeInstall: 'pkg install ollama'
+        };
+    }
     
     const instructions = {
         'darwin': {
@@ -546,8 +562,8 @@ function getOllamaInstallInstructions() {
                 '1. Review official installation options:',
                 '   https://github.com/ollama/ollama/blob/main/docs/linux.md',
                 '2. Prefer a package manager (apt/dnf/pacman) when available',
-                '3. Start service after install:',
-                '   sudo systemctl start ollama',
+                '3. Start Ollama after install:',
+                '   ollama serve',
                 '4. Test with: ollama run llama2:7b'
             ],
             alternativeInstall: 'Manual install: https://github.com/ollama/ollama/blob/main/docs/linux.md'
@@ -856,6 +872,13 @@ function calculateModelCompatibilityScore(model, hardware) {
     return Math.max(0, Math.min(100, Math.round(score)));
 }
 
+function formatGpuInventoryList(models = []) {
+    if (!Array.isArray(models) || models.length === 0) return 'None';
+    return models
+        .map(({ name, count }) => (count > 1 ? `${count}x ${name}` : name))
+        .join(' + ');
+}
+
 // Helper function to get hardware tier for display
 function getHardwareTierForDisplay(hardware) {
     const ram = hardware.memory.total;
@@ -863,9 +886,15 @@ function getHardwareTierForDisplay(hardware) {
     const gpuModel = hardware.gpu?.model || '';
     const vramGB = hardware.gpu?.vram || 0;
     
-    // Check if it's integrated GPU (should cap tier)
-    const isIntegratedGPU = /iris.*xe|iris.*graphics|uhd.*graphics|vega.*integrated|radeon.*graphics|intel.*integrated|integrated/i.test(gpuModel);
-    const hasDedicatedGPU = vramGB > 0 && !isIntegratedGPU;
+    const integratedGpuInventory = Array.isArray(hardware.summary?.integratedGpuModels)
+        ? hardware.summary.integratedGpuModels.map(({ name }) => name).join(' ')
+        : '';
+    const isIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
+        ? hardware.summary.hasIntegratedGPU
+        : /iris.*xe|iris.*graphics|uhd.*graphics|vega.*integrated|radeon.*graphics|intel.*integrated|integrated/i.test(`${gpuModel} ${integratedGpuInventory}`);
+    const hasDedicatedGPU = typeof hardware.summary?.hasDedicatedGPU === 'boolean'
+        ? hardware.summary.hasDedicatedGPU
+        : (vramGB > 0 && !isIntegratedGPU);
     const isAppleSilicon = process.platform === 'darwin' && (gpuModel.toLowerCase().includes('apple') || gpuModel.toLowerCase().includes('m1') || gpuModel.toLowerCase().includes('m2') || gpuModel.toLowerCase().includes('m3') || gpuModel.toLowerCase().includes('m4'));
     
     // Base tier calculation
@@ -932,6 +961,8 @@ function displaySystemInfo(hardware, analysis) {
     const cpuColor = hardware.cpu.cores >= 8 ? chalk.green : hardware.cpu.cores >= 4 ? chalk.yellow : chalk.red;
     const ramColor = hardware.memory.total >= 32 ? chalk.green : hardware.memory.total >= 16 ? chalk.yellow : chalk.red;
     const gpuColor = hardware.gpu.dedicated ? chalk.green : chalk.hex('#FFA500');
+    const integratedList = formatGpuInventoryList(hardware.gpu.integratedGpuModels || hardware.summary?.integratedGpuModels);
+    const dedicatedList = formatGpuInventoryList(hardware.gpu.dedicatedGpuModels || hardware.summary?.dedicatedGpuModels);
 
     const lines = [
         `${chalk.cyan('CPU:')} ${cpuColor(hardware.cpu.brand)} ${chalk.gray(`(${hardware.cpu.cores} cores, ${hardware.cpu.speed}GHz)`)}`,
@@ -939,6 +970,8 @@ function displaySystemInfo(hardware, analysis) {
         `${chalk.cyan('RAM:')} ${ramColor(hardware.memory.total + 'GB')}`,
         `${chalk.cyan('GPU:')} ${gpuColor(hardware.gpu.model || 'Not detected')}`,
         `${chalk.cyan('VRAM:')} ${hardware.gpu.vram === 0 && hardware.gpu.model && hardware.gpu.model.toLowerCase().includes('apple') ? 'Unified Memory' : `${hardware.gpu.vram || 'N/A'}GB`}${hardware.gpu.dedicated ? chalk.green(' (Dedicated)') : chalk.hex('#FFA500')(' (Integrated)')}`,
+        `${chalk.cyan('Dedicated GPUs:')} ${chalk.green(dedicatedList)}`,
+        `${chalk.cyan('Integrated GPUs:')} ${chalk.hex('#FFA500')(integratedList)}`,
     ];
 
     const tier = analysis.summary.hardwareTier?.replace('_', ' ').toUpperCase() || 'UNKNOWN';
@@ -5026,6 +5059,11 @@ program
             console.log(`  Tier: ${chalk.cyan(detector.getHardwareTier().replace('_', ' ').toUpperCase())}`);
             console.log(`  Max model size: ${chalk.green(detector.getMaxModelSize() + 'GB')}`);
             console.log(`  Best backend: ${chalk.cyan(hardware.summary.bestBackend)}`);
+            console.log(`  Dedicated GPUs: ${chalk.green(formatGpuInventoryList(hardware.summary.dedicatedGpuModels))}`);
+            console.log(`  Integrated GPUs: ${chalk.hex('#FFA500')(formatGpuInventoryList(hardware.summary.integratedGpuModels))}`);
+            if (hardware.summary.hasIntegratedGPU && hardware.summary.bestBackend === 'cpu') {
+                console.log(`  Assist path: ${chalk.yellow('Integrated/shared-memory GPU detected, runtime remains CPU')}`);
+            }
 
             // CPU
             if (hardware.cpu) {

package/bin/mcp-server.mjs

@@ -187,7 +187,7 @@ const ALLOWED_CLI_COMMANDS = new Set([
 
 const server = new McpServer({
   name: "llm-checker",
-  version: "3.4.0",
+  version: "3.5.7",
 });
 
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.4",
+  "version": "3.5.7",
   "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",
@@ -107,6 +107,7 @@
     "npm": ">=8.0.0"
   },
   "os": [
+    "android",
     "darwin",
     "linux",
     "win32"

package/src/ai/multi-objective-selector.js

@@ -9,6 +9,7 @@
  */
 
 const { MULTI_OBJECTIVE_WEIGHTS } = require('../models/scoring-config');
+const { normalizePlatform } = require('../utils/platform');
 
 class MultiObjectiveSelector {
     constructor() {
@@ -346,12 +347,22 @@ class MultiObjectiveSelector {
         const unified = isAppleSilicon;
         
         // Detect PC platform (Windows/Linux) to match main algorithm
-        const isPC = !isAppleSilicon && (process.platform === 'win32' || process.platform === 'linux');
+        const integratedGpuInventory = Array.isArray(hardware.summary?.integratedGpuModels)
+            ? hardware.summary.integratedGpuModels.map(({ name }) => name).join(' ')
+            : '';
+        const hasIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
+            ? hardware.summary.hasIntegratedGPU
+            : /iris xe|uhd.*graphics|vega.*integrated|radeon.*graphics/i.test(`${gpuModel} ${integratedGpuInventory}`);
+        const hasDedicatedGPU = typeof hardware.summary?.hasDedicatedGPU === 'boolean'
+            ? hardware.summary.hasDedicatedGPU
+            : Boolean(hardware.gpu?.dedicated || (vramGB > 0 && !hasIntegratedGPU));
+        const platform = normalizePlatform(hardware?.os?.platform || process.platform);
+        const isPC = !isAppleSilicon && (platform === 'win32' || platform === 'linux');
         
         // 1) Effective memory for model weights (45%) - Apple Silicon & PC optimized
         let effMem;
         
-        if (vramGB > 0 && !unified) {
+        if (hasDedicatedGPU && vramGB > 0 && !unified) {
             // Dedicated GPU path (Windows/Linux with discrete GPU)
             if (isPC) {
                 // PC-specific GPU memory calculation with offload support
@@ -446,9 +457,9 @@ class MultiObjectiveSelector {
             tier = bumpTier(tier, +1);  // High-end GPU boost
         } else if (!vramGB && !unified) {
             tier = bumpTier(tier, -1);  // CPU-only penalty (moderate)
-        } else if (/iris xe|uhd.*graphics|vega.*integrated|radeon.*graphics/i.test(gpuModel)) {
+        } else if (hasIntegratedGPU && !hasDedicatedGPU) {
             tier = bumpTier(tier, -1);  // iGPU penalty
-        } else if (vramGB > 0 && vramGB < 6) {
+        } else if (hasDedicatedGPU && vramGB > 0 && vramGB < 6) {
             tier = bumpTier(tier, -1);  // Low VRAM penalty
         }
         
@@ -658,7 +669,10 @@ class MultiObjectiveSelector {
         const cpuModel = hardware.cpu?.brand || hardware.cpu?.model || '';
         const gpuModel = hardware.gpu?.model || '';
         const cpu = cpuModel.toLowerCase();
-        const gpu = gpuModel.toLowerCase();
+        const integratedGpuInventory = Array.isArray(hardware.summary?.integratedGpuModels)
+            ? hardware.summary.integratedGpuModels.map(({ name }) => name).join(' ')
+            : '';
+        const gpu = `${gpuModel} ${integratedGpuInventory}`.toLowerCase();
         const cores = hardware.cpu?.physicalCores || hardware.cpu?.cores || 1;
         
         let specs = {
@@ -738,13 +752,19 @@ class MultiObjectiveSelector {
         const cores = hardware.cpu?.physicalCores || hardware.cpu?.cores || 1;
         const baseSpeed = hardware.cpu?.speed || 2.0;
         const vramGB = hardware.gpu?.vram || 0;
+        const hasIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
+            ? hardware.summary.hasIntegratedGPU
+            : false;
+        const hasDedicatedGPU = typeof hardware.summary?.hasDedicatedGPU === 'boolean'
+            ? hardware.summary.hasDedicatedGPU
+            : Boolean(hardware.gpu?.dedicated || (vramGB > 0 && !hasIntegratedGPU));
         
         // Use improved CPU estimation function for more realistic and varying speeds
         const hasAVX512 = cpuModel.toLowerCase().includes('intel') && 
                          (cpuModel.includes('13th') || cpuModel.includes('14th') || cpuModel.includes('12th'));
         
         // GPU-based calculation (dedicated GPU only)
-        if (vramGB > 0 && !gpuModel.toLowerCase().includes('iris') && !gpuModel.toLowerCase().includes('integrated')) {
+        if (hasDedicatedGPU && vramGB > 0) {
             let gpuTPS = 20; // Conservative GPU baseline
             if (gpuModel.toLowerCase().includes('gb10') ||
                 gpuModel.toLowerCase().includes('grace blackwell') ||
@@ -780,7 +800,7 @@ class MultiObjectiveSelector {
                 threads: cores,
                 paramsB: params,
                 avx512: hasAVX512,
-                isIrisXe: gpuModel.toLowerCase().includes('iris xe')
+                isIrisXe: hasIntegratedGPU && gpuModel.toLowerCase().includes('iris xe')
             });
         }
     }

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

@@ -4,9 +4,10 @@
  * Focuses on AVX2, AVX512, AMX, and other SIMD extensions
  */
 
-const { execSync } = require('child_process');
+const childProcess = require('child_process');
 const os = require('os');
 const fs = require('fs');
+const { normalizePlatform } = require('../../utils/platform');
 
 class CPUDetector {
     constructor() {
@@ -87,10 +88,12 @@ class CPUDetector {
      * Get physical core count
      */
     getPhysicalCores() {
+        const platform = normalizePlatform();
+
         try {
-            if (process.platform === 'darwin') {
-                return parseInt(execSync('sysctl -n hw.physicalcpu', { encoding: 'utf8', timeout: 5000 }).trim());
-            } else if (process.platform === 'linux') {
+            if (platform === 'darwin') {
+                return parseInt(childProcess.execSync('sysctl -n hw.physicalcpu', { encoding: 'utf8', timeout: 5000 }).trim());
+            } else if (platform === 'linux') {
                 const cpuInfo = fs.readFileSync('/proc/cpuinfo', 'utf8');
                 const coreIds = new Set();
                 const matches = cpuInfo.matchAll(/core id\s*:\s*(\d+)/g);
@@ -98,7 +101,7 @@ class CPUDetector {
                     coreIds.add(match[1]);
                 }
                 return coreIds.size || os.cpus().length;
-            } else if (process.platform === 'win32') {
+            } else if (platform === 'win32') {
                 const physicalCores = this.getWindowsPhysicalCoreCount();
                 return physicalCores || os.cpus().length;
             }
@@ -112,18 +115,20 @@ class CPUDetector {
      * Get maximum CPU frequency
      */
     getMaxFrequency() {
+        const platform = normalizePlatform();
+
         try {
-            if (process.platform === 'darwin') {
+            if (platform === 'darwin') {
                 // macOS doesn't expose max frequency easily
                 const cpus = os.cpus();
                 return cpus.length > 0 ? cpus[0].speed : 0;
-            } else if (process.platform === 'linux') {
+            } else if (platform === 'linux') {
                 const maxFreq = fs.readFileSync(
                     '/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq',
                     'utf8'
                 );
                 return Math.round(parseInt(maxFreq) / 1000);  // kHz to MHz
-            } else if (process.platform === 'win32') {
+            } else if (platform === 'win32') {
                 const maxClock = this.getWindowsMaxClockSpeed();
                 return maxClock || (os.cpus()[0]?.speed || 0);
             }
@@ -137,7 +142,37 @@ class CPUDetector {
      * Execute shell command with consistent options.
      */
     runCommand(command) {
-        return execSync(command, { encoding: 'utf8', timeout: 5000 });
+        const baseOptions = {
+            encoding: 'utf8',
+            timeout: 5000
+        };
+
+        if (normalizePlatform() === 'win32') {
+            const result = childProcess.spawnSync(command, {
+                ...baseOptions,
+                shell: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true
+            });
+
+            if (result.error) {
+                throw result.error;
+            }
+
+            if (result.status !== 0) {
+                const stderr = String(result.stderr || '').trim();
+                const stdout = String(result.stdout || '').trim();
+                const error = new Error(stderr || stdout || `Command failed: ${command}`);
+                error.status = result.status;
+                error.stdout = result.stdout;
+                error.stderr = result.stderr;
+                throw error;
+            }
+
+            return result.stdout;
+        }
+
+        return childProcess.execSync(command, baseOptions);
     }
 
     /**
@@ -206,13 +241,15 @@ class CPUDetector {
             l3: 0
         };
 
+        const platform = normalizePlatform();
+
         try {
-            if (process.platform === 'darwin') {
-                cache.l1d = parseInt(execSync('sysctl -n hw.l1dcachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 || 0;
-                cache.l1i = parseInt(execSync('sysctl -n hw.l1icachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 || 0;
-                cache.l2 = parseInt(execSync('sysctl -n hw.l2cachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 / 1024 || 0;
-                cache.l3 = parseInt(execSync('sysctl -n hw.l3cachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 / 1024 || 0;
-            } else if (process.platform === 'linux') {
+            if (platform === 'darwin') {
+                cache.l1d = parseInt(childProcess.execSync('sysctl -n hw.l1dcachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 || 0;
+                cache.l1i = parseInt(childProcess.execSync('sysctl -n hw.l1icachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 || 0;
+                cache.l2 = parseInt(childProcess.execSync('sysctl -n hw.l2cachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 / 1024 || 0;
+                cache.l3 = parseInt(childProcess.execSync('sysctl -n hw.l3cachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 / 1024 || 0;
+            } else if (platform === 'linux') {
                 // Parse from /sys/devices/system/cpu/cpu0/cache/
                 const cachePath = '/sys/devices/system/cpu/cpu0/cache';
                 if (fs.existsSync(cachePath)) {
@@ -268,8 +305,10 @@ class CPUDetector {
             bestSimd: 'none'
         };
 
+        const platform = normalizePlatform();
+
         try {
-            if (process.platform === 'darwin') {
+            if (platform === 'darwin') {
                 // For Apple Silicon (ARM64), use ARM features
                 if (process.arch === 'arm64') {
                     caps.neon = true;  // All Apple Silicon has NEON
@@ -279,12 +318,12 @@ class CPUDetector {
                 } else {
                     // Intel Mac - check via sysctl
                     try {
-                        const features = execSync('sysctl -n machdep.cpu.features', {
+                        const features = childProcess.execSync('sysctl -n machdep.cpu.features', {
                             encoding: 'utf8',
                             timeout: 5000
                         }).toLowerCase();
 
-                        const leafFeatures = execSync('sysctl -n machdep.cpu.leaf7_features', {
+                        const leafFeatures = childProcess.execSync('sysctl -n machdep.cpu.leaf7_features', {
                             encoding: 'utf8',
                             timeout: 5000
                         }).toLowerCase();
@@ -308,7 +347,7 @@ class CPUDetector {
                     }
                 }
 
-            } else if (process.platform === 'linux') {
+            } else if (platform === 'linux') {
                 // Linux - check /proc/cpuinfo
                 const cpuInfo = fs.readFileSync('/proc/cpuinfo', 'utf8').toLowerCase();
                 const flags = cpuInfo.match(/flags\s*:\s*(.+)/)?.[1] || '';
@@ -334,7 +373,7 @@ class CPUDetector {
                     caps.dotprod = flags.includes('asimddp');
                 }
 
-            } else if (process.platform === 'win32') {
+            } else if (platform === 'win32') {
                 // Windows - use WMIC or assume based on CPU model
                 const cpuName = os.cpus()[0]?.model?.toLowerCase() || '';
 

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

@@ -15,6 +15,10 @@ class CUDADetector {
         this.detectionMode = null;
     }
 
+    execCommand(command, options = {}) {
+        return execSync(command, options);
+    }
+
     /**
      * Check if CUDA is available
      */
@@ -43,7 +47,7 @@ class CUDADetector {
 
     hasNvidiaSMI() {
         try {
-            execSync('nvidia-smi --version', {
+            this.execCommand('nvidia-smi --version', {
                 encoding: 'utf8',
                 timeout: 5000,
                 stdio: ['pipe', 'pipe', 'pipe']
@@ -142,7 +146,7 @@ class CUDADetector {
         }
 
         try {
-            execSync('nvcc --version', {
+            this.execCommand('nvcc --version', {
                 encoding: 'utf8',
                 timeout: 5000,
                 stdio: ['pipe', 'pipe', 'pipe']
@@ -197,17 +201,18 @@ class CUDADetector {
 
         try {
             // Get driver and CUDA version
-            const versionInfo = execSync('nvidia-smi --query-gpu=driver_version --format=csv,noheader,nounits', {
+            const versionInfo = this.execCommand('nvidia-smi --query-gpu=driver_version --format=csv,noheader,nounits', {
                 encoding: 'utf8',
                 timeout: 5000
             }).trim().split('\n')[0];
             result.driver = versionInfo;
 
-            // Get CUDA version from nvidia-smi header
-            const header = execSync('nvidia-smi | head -n 3', {
+            // Parse the nvidia-smi banner in JS so Windows does not require shell-only tools like `head`.
+            const banner = this.execCommand('nvidia-smi', {
                 encoding: 'utf8',
                 timeout: 5000
             });
+            const header = banner.split('\n').slice(0, 3).join('\n');
             const cudaMatch = header.match(/CUDA Version:\s*([\d.]+)/);
             if (cudaMatch) {
                 result.cuda = cudaMatch[1];
@@ -237,7 +242,7 @@ class CUDADetector {
                 'clocks.max.sm'
             ].join(',');
 
-            const gpuData = execSync(
+            const gpuData = this.execCommand(
                 `nvidia-smi --query-gpu=${query} --format=csv,noheader,nounits`,
                 { encoding: 'utf8', timeout: 10000 }
             ).trim();
@@ -286,7 +291,7 @@ class CUDADetector {
         } catch (e) {
             // Fallback to simpler query
             try {
-                const simpleQuery = execSync(
+                const simpleQuery = this.execCommand(
                     'nvidia-smi --query-gpu=name,memory.total --format=csv,noheader,nounits',
                     { encoding: 'utf8', timeout: 5000 }
                 ).trim();
@@ -408,7 +413,7 @@ class CUDADetector {
         }
 
         try {
-            const nvccVersion = execSync('nvcc --version', {
+            const nvccVersion = this.execCommand('nvcc --version', {
                 encoding: 'utf8',
                 timeout: 5000,
                 stdio: ['pipe', 'pipe', 'pipe']