@edgible-team/cli 1.0.1

package/dist/detection/SystemCapabilityDetector.js

@@ -0,0 +1,1244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemCapabilityDetector = void 0;
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+class SystemCapabilityDetector {
+    /**
+     * Detect all system capabilities
+     */
+    static async detectCapabilities() {
+        const cpu = this.detectCpu();
+        const memory = this.detectMemory();
+        const gpu = await this.detectGpu();
+        const platform = os.platform();
+        const gpuDriverSupport = await this.detectGpuDriverSupport(gpu);
+        const recommendedModels = this.recommendLLMModels(cpu, memory, gpu);
+        const hasEnoughResources = recommendedModels.some((m) => m.suitability === 'excellent' || m.suitability === 'good');
+        return {
+            cpu,
+            memory,
+            gpu,
+            platform,
+            hasEnoughResources,
+            recommendedModels,
+            gpuDriverSupport,
+        };
+    }
+    /**
+     * Detect CPU information
+     */
+    static detectCpu() {
+        const cpus = os.cpus();
+        const firstCpu = cpus[0];
+        const model = firstCpu?.model || 'Unknown';
+        const cores = cpus.length;
+        const threads = cores; // os.cpus() returns logical cores
+        const architecture = os.arch();
+        const speed = firstCpu?.speed ? firstCpu.speed / 1000 : 0; // Convert MHz to GHz
+        return {
+            model,
+            cores,
+            threads,
+            architecture,
+            speed,
+        };
+    }
+    /**
+     * Detect memory information
+     */
+    static detectMemory() {
+        const total = os.totalmem();
+        const free = os.freemem();
+        const used = total - free;
+        return {
+            total,
+            free,
+            used,
+            totalGB: this.bytesToGB(total),
+            freeGB: this.bytesToGB(free),
+            usedGB: this.bytesToGB(used),
+        };
+    }
+    /**
+     * Detect GPU information
+     */
+    static async detectGpu() {
+        try {
+            // Try NVIDIA GPU first (most common for ML)
+            if (this.hasCommand('nvidia-smi')) {
+                return await this.detectNvidiaGpu();
+            }
+            // Try macOS GPU detection (Apple Silicon or Intel)
+            if (process.platform === 'darwin') {
+                return await this.detectMacOSGpu();
+            }
+            // Try AMD GPU detection (multiple methods)
+            if (process.platform === 'linux') {
+                // Try ROCm first (for data center GPUs)
+                if (this.hasCommand('rocm-smi')) {
+                    const rocmGpu = await this.detectAmdGpu();
+                    if (rocmGpu)
+                        return rocmGpu;
+                }
+                // Try Linux AMD GPU detection (consumer GPUs)
+                const linuxAmdGpu = await this.detectAmdGpuLinux();
+                if (linuxAmdGpu)
+                    return linuxAmdGpu;
+                // Fall back to generic PCI detection
+                return await this.detectGpuViaLspci();
+            }
+            // Try Windows GPU detection (includes AMD VRAM)
+            if (process.platform === 'win32') {
+                return await this.detectGpuViaWmic();
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Detect NVIDIA GPU using nvidia-smi
+     */
+    static async detectNvidiaGpu() {
+        try {
+            const output = (0, child_process_1.execSync)('nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits', {
+                encoding: 'utf8',
+                timeout: 5000,
+            });
+            const lines = output.trim().split('\n');
+            if (lines.length === 0) {
+                return null;
+            }
+            // Get first GPU
+            const line = lines[0].trim();
+            const parts = line.split(',');
+            if (parts.length < 2) {
+                return null;
+            }
+            const name = parts[0].trim();
+            const vramMB = parseInt(parts[1].trim(), 10);
+            const driverVersion = parts[2]?.trim();
+            return {
+                name,
+                vendor: 'NVIDIA',
+                vramGB: Math.round((vramMB / 1024) * 10) / 10, // Round to 1 decimal
+                driverVersion,
+                available: true,
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Detect AMD GPU using rocm-smi (ROCm drivers, typically data center GPUs)
+     */
+    static async detectAmdGpu() {
+        try {
+            const output = (0, child_process_1.execSync)('rocm-smi --showproductname --showmeminfo vram --showdriverversion', {
+                encoding: 'utf8',
+                timeout: 5000,
+            });
+            // Parse output (format varies)
+            const nameMatch = output.match(/Card series:\s*(.+)/i);
+            const vramMatch = output.match(/vram.*?(\d+)\s*MB/i);
+            const driverMatch = output.match(/Driver version:\s*(.+)/i);
+            return {
+                name: nameMatch?.[1] || 'AMD GPU',
+                vendor: 'AMD',
+                vramGB: vramMatch ? Math.round((parseInt(vramMatch[1], 10) / 1024) * 10) / 10 : undefined,
+                driverVersion: driverMatch?.[1],
+                available: true,
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Detect AMD GPU on Linux using amdgpu driver (consumer GPUs)
+     */
+    static async detectAmdGpuLinux() {
+        try {
+            // First check if AMD GPU exists via lspci
+            const lspciOutput = (0, child_process_1.execSync)('lspci | grep -i "amd\\|ati\\|radeon"', {
+                encoding: 'utf8',
+                timeout: 5000,
+            });
+            if (!lspciOutput.trim()) {
+                return null;
+            }
+            // Extract GPU name from lspci
+            const lines = lspciOutput.trim().split('\n');
+            const firstLine = lines[0];
+            const gpuName = firstLine.split(':')[2]?.trim() || 'AMD GPU';
+            // Try to get VRAM from /sys/class/drm/
+            // Look for card* devices
+            const drmCards = (0, child_process_1.execSync)('ls -d /sys/class/drm/card* 2>/dev/null | head -1', {
+                encoding: 'utf8',
+                timeout: 2000,
+            }).trim();
+            if (drmCards) {
+                // Try to read VRAM size from device
+                try {
+                    // Check if it's an AMD GPU by looking at device path
+                    const devicePath = (0, child_process_1.execSync)(`readlink -f ${drmCards}`, {
+                        encoding: 'utf8',
+                        timeout: 2000,
+                    }).trim();
+                    if (devicePath.includes('amdgpu')) {
+                        // Try to get VRAM from mem_info_vram_total (in bytes)
+                        try {
+                            const vramBytes = (0, child_process_1.execSync)(`cat ${drmCards}/device/mem_info_vram_total 2>/dev/null`, {
+                                encoding: 'utf8',
+                                timeout: 2000,
+                            }).trim();
+                            if (vramBytes && !isNaN(parseInt(vramBytes, 10))) {
+                                const vramGB = Math.round((parseInt(vramBytes, 10) / (1024 * 1024 * 1024)) * 10) / 10;
+                                return {
+                                    name: gpuName,
+                                    vendor: 'AMD',
+                                    vramGB,
+                                    available: true,
+                                };
+                            }
+                        }
+                        catch {
+                            // Try alternative method
+                        }
+                        // Alternative: try to get from radeontop or other tools
+                        if (this.hasCommand('radeontop')) {
+                            try {
+                                // radeontop can show VRAM but requires running, so skip for now
+                            }
+                            catch {
+                                // Ignore
+                            }
+                        }
+                        // Try to get from lspci -v (may show memory size)
+                        try {
+                            const lspciVOutput = (0, child_process_1.execSync)(`lspci -v -s ${firstLine.split(' ')[0]}`, {
+                                encoding: 'utf8',
+                                timeout: 3000,
+                            });
+                            // Look for memory size in output (format: Memory at ... [size=8G])
+                            const memoryMatch = lspciVOutput.match(/Memory.*?\[size=(\d+)([KMGT]?)\]/i);
+                            if (memoryMatch) {
+                                let size = parseInt(memoryMatch[1], 10);
+                                const unit = memoryMatch[2].toUpperCase();
+                                if (unit === 'G') {
+                                    // Already in GB
+                                }
+                                else if (unit === 'M') {
+                                    size = size / 1024;
+                                }
+                                else if (unit === 'T') {
+                                    size = size * 1024;
+                                }
+                                // K is too small, ignore
+                                if (size >= 1) {
+                                    // Likely VRAM if it's a reasonable size
+                                    return {
+                                        name: gpuName,
+                                        vendor: 'AMD',
+                                        vramGB: Math.round(size * 10) / 10,
+                                        available: true,
+                                    };
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignore
+                        }
+                    }
+                }
+                catch {
+                    // Ignore errors
+                }
+            }
+            // If we found an AMD GPU but couldn't get VRAM, return basic info
+            return {
+                name: gpuName,
+                vendor: 'AMD',
+                available: true,
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Detect GPU via lspci (Linux)
+     */
+    static async detectGpuViaLspci() {
+        try {
+            const output = (0, child_process_1.execSync)('lspci | grep -i "vga\\|3d\\|display"', {
+                encoding: 'utf8',
+                timeout: 5000,
+            });
+            const lines = output.trim().split('\n');
+            if (lines.length === 0) {
+                return null;
+            }
+            const line = lines[0];
+            let vendor = 'Unknown';
+            let name = 'Unknown';
+            if (line.includes('NVIDIA')) {
+                vendor = 'NVIDIA';
+                name = line.split(':')[2]?.trim() || 'NVIDIA GPU';
+            }
+            else if (line.includes('AMD') || line.includes('ATI')) {
+                vendor = 'AMD';
+                name = line.split(':')[2]?.trim() || 'AMD GPU';
+            }
+            else if (line.includes('Intel')) {
+                vendor = 'Intel';
+                name = line.split(':')[2]?.trim() || 'Intel GPU';
+            }
+            else {
+                name = line.split(':')[2]?.trim() || 'Unknown GPU';
+            }
+            return {
+                name,
+                vendor,
+                available: true,
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Detect GPU on macOS (Apple Silicon or Intel)
+     */
+    static async detectMacOSGpu() {
+        try {
+            // Use system_profiler to get GPU information
+            const output = (0, child_process_1.execSync)('system_profiler SPDisplaysDataType', {
+                encoding: 'utf8',
+                timeout: 5000,
+            });
+            // Check if it's Apple Silicon
+            const isAppleSilicon = output.includes('Apple') && (output.includes('M1') ||
+                output.includes('M2') ||
+                output.includes('M3') ||
+                output.includes('M4') ||
+                output.includes('Apple GPU'));
+            // Extract GPU name - try multiple patterns
+            let name = 'Apple GPU';
+            const chipsetMatch = output.match(/Chipset Model:\s*(.+)/i);
+            const modelMatch = output.match(/Model:\s*(.+)/i);
+            const deviceMatch = output.match(/Device ID:\s*(.+)/i);
+            if (chipsetMatch) {
+                name = chipsetMatch[1].trim();
+            }
+            else if (modelMatch) {
+                name = modelMatch[1].trim();
+            }
+            // Extract VRAM - try multiple patterns for different GPU types
+            let vramGB;
+            // Pattern 1: "VRAM (Total): 4096 MB" or "VRAM: 4096 MB"
+            let vramMatch = output.match(/VRAM\s*\(?Total\)?:\s*(\d+)\s*MB/i) ||
+                output.match(/VRAM:\s*(\d+)\s*MB/i);
+            if (vramMatch) {
+                vramGB = Math.round((parseInt(vramMatch[1], 10) / 1024) * 10) / 10;
+            }
+            else {
+                // Pattern 2: "VRAM (Dynamic, Max): 4096 MB" - for AMD GPUs
+                vramMatch = output.match(/VRAM\s*\(Dynamic[^)]*\):\s*(\d+)\s*MB/i);
+                if (vramMatch) {
+                    vramGB = Math.round((parseInt(vramMatch[1], 10) / 1024) * 10) / 10;
+                }
+                else {
+                    // Pattern 3: Look for memory size in different formats
+                    // Some AMD GPUs show: "Memory: 4096 MB" or "Total Memory: 4096 MB"
+                    vramMatch = output.match(/(?:Total\s+)?Memory:\s*(\d+)\s*MB/i);
+                    if (vramMatch) {
+                        const memMB = parseInt(vramMatch[1], 10);
+                        // Only consider it VRAM if it's a reasonable size (>= 512MB, <= 64GB)
+                        if (memMB >= 512 && memMB <= 65536) {
+                            vramGB = Math.round((memMB / 1024) * 10) / 10;
+                        }
+                    }
+                }
+            }
+            // For Apple Silicon, VRAM is shared with system RAM
+            if (isAppleSilicon && !vramGB) {
+                // Apple Silicon uses unified memory - we'll note this in the reasoning
+                // but don't set a specific VRAM value as it's shared and dynamically allocated
+            }
+            // Determine vendor
+            let vendor = 'Apple';
+            if (isAppleSilicon) {
+                // Extract chip model (M1, M2, M3, etc.)
+                const chipMatch = output.match(/(M[1-4]\s*(?:Pro|Max|Ultra)?)/i) ||
+                    name.match(/(M[1-4]\s*(?:Pro|Max|Ultra)?)/i);
+                if (chipMatch) {
+                    vendor = `Apple Silicon (${chipMatch[1]})`;
+                }
+                else {
+                    vendor = 'Apple Silicon';
+                }
+            }
+            else if (output.includes('AMD') || name.includes('AMD') || name.includes('Radeon')) {
+                vendor = 'AMD';
+                // For AMD GPUs, try to extract more specific model info
+                const radeonMatch = output.match(/Radeon\s+(Pro\s+)?([A-Z0-9\s]+)/i) ||
+                    name.match(/Radeon\s+(Pro\s+)?([A-Z0-9\s]+)/i);
+                if (radeonMatch && !name.includes('Radeon')) {
+                    name = `AMD Radeon ${radeonMatch[2]?.trim() || name}`;
+                }
+            }
+            else if (output.includes('NVIDIA')) {
+                vendor = 'NVIDIA';
+            }
+            else if (output.includes('Intel')) {
+                vendor = 'Intel';
+            }
+            return {
+                name,
+                vendor,
+                vramGB,
+                available: true,
+            };
+        }
+        catch (error) {
+            // Fallback: try to detect Apple Silicon via uname
+            try {
+                const arch = (0, child_process_1.execSync)('uname -m', { encoding: 'utf8', timeout: 2000 }).trim();
+                if (arch === 'arm64') {
+                    // Likely Apple Silicon
+                    const chipInfo = (0, child_process_1.execSync)('sysctl -n machdep.cpu.brand_string', {
+                        encoding: 'utf8',
+                        timeout: 2000,
+                    }).trim();
+                    return {
+                        name: 'Apple GPU',
+                        vendor: chipInfo.includes('Apple') ? 'Apple Silicon' : 'Apple',
+                        available: true,
+                    };
+                }
+            }
+            catch {
+                // Ignore fallback errors
+            }
+            return null;
+        }
+    }
+    /**
+     * Detect GPU via WMIC (Windows) - includes VRAM for AMD and NVIDIA
+     */
+    static async detectGpuViaWmic() {
+        try {
+            // Get GPU name and adapter RAM (VRAM)
+            const output = (0, child_process_1.execSync)('wmic path win32_VideoController get name,AdapterRAM,DriverVersion', {
+                encoding: 'utf8',
+                timeout: 5000,
+            });
+            const lines = output.trim().split('\n').filter((line) => line.trim() && !line.includes('Name'));
+            if (lines.length === 0) {
+                return null;
+            }
+            // Parse the first GPU
+            const firstLine = lines[0].trim();
+            // WMIC output format can vary, try to parse it
+            // Format is typically: Name    AdapterRAM    DriverVersion
+            // Try to extract name (usually first field)
+            const parts = firstLine.split(/\s{2,}/); // Split on multiple spaces
+            let name = parts[0]?.trim() || firstLine;
+            let vramBytes;
+            let driverVersion;
+            // Try to get VRAM from AdapterRAM field
+            try {
+                const vramOutput = (0, child_process_1.execSync)(`wmic path win32_VideoController where "Name='${name.replace(/'/g, "''")}'" get AdapterRAM /value`, {
+                    encoding: 'utf8',
+                    timeout: 3000,
+                });
+                const vramMatch = vramOutput.match(/AdapterRAM=(\d+)/);
+                if (vramMatch) {
+                    vramBytes = parseInt(vramMatch[1], 10);
+                }
+            }
+            catch {
+                // Try alternative: get all info in one query
+                try {
+                    const fullOutput = (0, child_process_1.execSync)(`wmic path win32_VideoController where "Name='${name.replace(/'/g, "''")}'" get AdapterRAM,DriverVersion /format:list`, {
+                        encoding: 'utf8',
+                        timeout: 3000,
+                    });
+                    const vramMatch = fullOutput.match(/AdapterRAM=(\d+)/);
+                    const driverMatch = fullOutput.match(/DriverVersion=(.+)/);
+                    if (vramMatch) {
+                        vramBytes = parseInt(vramMatch[1], 10);
+                    }
+                    if (driverMatch) {
+                        driverVersion = driverMatch[1].trim();
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+            }
+            let vendor = 'Unknown';
+            if (name.includes('NVIDIA')) {
+                vendor = 'NVIDIA';
+            }
+            else if (name.includes('AMD') || name.includes('Radeon')) {
+                vendor = 'AMD';
+            }
+            else if (name.includes('Intel')) {
+                vendor = 'Intel';
+            }
+            const vramGB = vramBytes ? Math.round((vramBytes / (1024 * 1024 * 1024)) * 10) / 10 : undefined;
+            return {
+                name,
+                vendor,
+                vramGB,
+                driverVersion,
+                available: true,
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Detect GPU driver support and Docker GPU runtime availability
+     */
+    static async detectGpuDriverSupport(gpu) {
+        const support = {
+            cuda: {
+                available: false,
+                toolkitAvailable: false,
+            },
+            rocm: {
+                available: false,
+            },
+            metal: {
+                available: false,
+            },
+            dockerGpuSupport: {
+                available: false,
+            },
+            ollamaGpuReady: false,
+        };
+        // Detect CUDA (NVIDIA)
+        if (this.hasCommand('nvidia-smi')) {
+            try {
+                const nvidiaOutput = (0, child_process_1.execSync)('nvidia-smi --query-gpu=driver_version,cuda_version --format=csv,noheader', {
+                    encoding: 'utf8',
+                    timeout: 3000,
+                });
+                const lines = nvidiaOutput.trim().split('\n');
+                if (lines.length > 0) {
+                    const parts = lines[0].split(',');
+                    support.cuda.available = true;
+                    if (parts[1]) {
+                        support.cuda.version = parts[1].trim();
+                    }
+                }
+            }
+            catch {
+                // nvidia-smi available but query failed
+            }
+            // Check for CUDA toolkit
+            if (this.hasCommand('nvcc')) {
+                try {
+                    const nvccOutput = (0, child_process_1.execSync)('nvcc --version', {
+                        encoding: 'utf8',
+                        timeout: 2000,
+                    });
+                    const versionMatch = nvccOutput.match(/release\s+(\d+\.\d+)/i);
+                    if (versionMatch) {
+                        support.cuda.toolkitAvailable = true;
+                        if (!support.cuda.version) {
+                            support.cuda.version = versionMatch[1];
+                        }
+                    }
+                }
+                catch {
+                    // nvcc available but version check failed
+                }
+            }
+        }
+        // Detect ROCm (AMD)
+        if (this.hasCommand('rocm-smi')) {
+            try {
+                const rocmOutput = (0, child_process_1.execSync)('rocm-smi --version', {
+                    encoding: 'utf8',
+                    timeout: 3000,
+                });
+                support.rocm.available = true;
+                const versionMatch = rocmOutput.match(/version\s+(\d+\.\d+\.\d+)/i);
+                if (versionMatch) {
+                    support.rocm.version = versionMatch[1];
+                }
+            }
+            catch {
+                // rocm-smi available but version check failed
+            }
+        }
+        // Detect Metal (macOS)
+        if (process.platform === 'darwin') {
+            try {
+                // Check if Metal is available (it's built into macOS)
+                const metalCheck = (0, child_process_1.execSync)('system_profiler SPDisplaysDataType | grep -i "metal"', {
+                    encoding: 'utf8',
+                    timeout: 2000,
+                });
+                support.metal.available = true;
+            }
+            catch {
+                // Try alternative check
+                try {
+                    // Metal is available on all modern macOS systems
+                    const osVersion = (0, child_process_1.execSync)('sw_vers -productVersion', {
+                        encoding: 'utf8',
+                        timeout: 2000,
+                    });
+                    const majorVersion = parseInt(osVersion.split('.')[0], 10);
+                    // Metal has been available since macOS 10.11
+                    support.metal.available = majorVersion >= 10;
+                }
+                catch {
+                    support.metal.available = false;
+                }
+            }
+        }
+        // Detect Docker GPU support
+        if (this.hasCommand('docker')) {
+            try {
+                // Check for NVIDIA Container Runtime
+                const dockerInfo = (0, child_process_1.execSync)('docker info 2>/dev/null', {
+                    encoding: 'utf8',
+                    timeout: 3000,
+                });
+                if (dockerInfo.includes('nvidia') || dockerInfo.includes('gpu')) {
+                    support.dockerGpuSupport.available = true;
+                }
+                // Check for nvidia-container-runtime
+                if (this.hasCommand('nvidia-container-runtime')) {
+                    support.dockerGpuSupport.nvidiaContainerRuntime = true;
+                    support.dockerGpuSupport.runtime = 'nvidia';
+                    support.dockerGpuSupport.available = true;
+                }
+                // Check for nvidia-docker (legacy)
+                if (this.hasCommand('nvidia-docker')) {
+                    support.dockerGpuSupport.nvidiaDocker = true;
+                    support.dockerGpuSupport.runtime = 'nvidia';
+                    support.dockerGpuSupport.available = true;
+                }
+                // Check Docker daemon configuration for GPU runtimes
+                try {
+                    const dockerVersion = (0, child_process_1.execSync)('docker version --format "{{.Server.Version}}"', {
+                        encoding: 'utf8',
+                        timeout: 2000,
+                    });
+                    // Try to test GPU access in Docker
+                    if (support.cuda.available) {
+                        try {
+                            // Check if nvidia runtime is available
+                            const runtimes = (0, child_process_1.execSync)('docker info --format "{{.Runtimes}}"', {
+                                encoding: 'utf8',
+                                timeout: 2000,
+                            });
+                            if (runtimes.includes('nvidia') || runtimes.includes('gpu')) {
+                                support.dockerGpuSupport.available = true;
+                                support.dockerGpuSupport.runtime = 'nvidia';
+                            }
+                        }
+                        catch {
+                            // Ignore
+                        }
+                    }
+                    if (support.rocm.available) {
+                        try {
+                            const runtimes = (0, child_process_1.execSync)('docker info --format "{{.Runtimes}}"', {
+                                encoding: 'utf8',
+                                timeout: 2000,
+                            });
+                            if (runtimes.includes('rocm')) {
+                                support.dockerGpuSupport.available = true;
+                                support.dockerGpuSupport.runtime = 'rocm';
+                            }
+                        }
+                        catch {
+                            // Ignore
+                        }
+                    }
+                }
+                catch {
+                    // Docker not running or can't query
+                }
+            }
+            catch {
+                // Docker not available or not running
+            }
+        }
+        // Determine Ollama GPU readiness
+        if (gpu) {
+            if (gpu.vendor === 'NVIDIA' || gpu.vendor.includes('NVIDIA')) {
+                if (support.cuda.available && support.dockerGpuSupport.available) {
+                    support.ollamaGpuReady = true;
+                    support.ollamaGpuReason = 'NVIDIA GPU with CUDA and Docker GPU support available';
+                }
+                else if (support.cuda.available) {
+                    support.ollamaGpuReady = true;
+                    support.ollamaGpuReason = 'NVIDIA GPU with CUDA available (Docker GPU support not detected)';
+                }
+                else {
+                    support.ollamaGpuReady = false;
+                    support.ollamaGpuReason = 'NVIDIA GPU detected but CUDA drivers not available';
+                }
+            }
+            else if (gpu.vendor === 'AMD' || gpu.vendor.includes('AMD')) {
+                if (support.rocm.available && support.dockerGpuSupport.available) {
+                    support.ollamaGpuReady = true;
+                    support.ollamaGpuReason = 'AMD GPU with ROCm and Docker GPU support available';
+                }
+                else if (support.rocm.available) {
+                    support.ollamaGpuReady = true;
+                    support.ollamaGpuReason = 'AMD GPU with ROCm available (Docker GPU support not detected)';
+                }
+                else {
+                    support.ollamaGpuReady = false;
+                    support.ollamaGpuReason = 'AMD GPU detected but ROCm drivers not available';
+                }
+            }
+            else if (gpu.vendor.includes('Apple Silicon') || gpu.vendor.includes('Apple')) {
+                if (support.metal.available) {
+                    support.ollamaGpuReady = true;
+                    support.ollamaGpuReason = 'Apple Silicon GPU with Metal support available';
+                }
+                else {
+                    support.ollamaGpuReady = false;
+                    support.ollamaGpuReason = 'Apple Silicon GPU detected but Metal support not available';
+                }
+            }
+            else {
+                support.ollamaGpuReady = false;
+                support.ollamaGpuReason = `GPU detected (${gpu.vendor}) but no compatible drivers found`;
+            }
+        }
+        else {
+            support.ollamaGpuReady = false;
+            support.ollamaGpuReason = 'No GPU detected - Ollama will run in CPU-only mode';
+        }
+        return support;
+    }
+    /**
+     * Check if a command is available
+     */
+    static hasCommand(command) {
+        try {
+            (0, child_process_1.execSync)(`which ${command}`, { encoding: 'utf8', timeout: 1000, stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            try {
+                // Windows fallback
+                (0, child_process_1.execSync)(`where ${command}`, { encoding: 'utf8', timeout: 1000, stdio: 'ignore' });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    /**
+     * Recommend LLM models based on system capabilities
+     */
+    static recommendLLMModels(cpu, memory, gpu) {
+        const recommendations = [];
+        // Model definitions with requirements
+        const models = [
+            {
+                modelName: 'Llama 3.2 1B',
+                size: '1B',
+                parameters: '1 billion',
+                minRamGB: 2,
+                recommendedRamGB: 4,
+                minVramGB: undefined,
+                recommendedVramGB: undefined,
+            },
+            {
+                modelName: 'Llama 3.2 3B',
+                size: '3B',
+                parameters: '3 billion',
+                minRamGB: 4,
+                recommendedRamGB: 8,
+                minVramGB: 4,
+                recommendedVramGB: 6,
+            },
+            {
+                modelName: 'Llama 3.1 8B',
+                size: '8B',
+                parameters: '8 billion',
+                minRamGB: 8,
+                recommendedRamGB: 16,
+                minVramGB: 6,
+                recommendedVramGB: 8,
+            },
+            {
+                modelName: 'Llama 3.1 70B',
+                size: '70B',
+                parameters: '70 billion',
+                minRamGB: 40,
+                recommendedRamGB: 64,
+                minVramGB: 40,
+                recommendedVramGB: 48,
+            },
+            {
+                modelName: 'Mistral 7B',
+                size: '7B',
+                parameters: '7 billion',
+                minRamGB: 8,
+                recommendedRamGB: 16,
+                minVramGB: 6,
+                recommendedVramGB: 8,
+            },
+            {
+                modelName: 'Phi-3 Mini (3.8B)',
+                size: '3.8B',
+                parameters: '3.8 billion',
+                minRamGB: 4,
+                recommendedRamGB: 8,
+                minVramGB: 4,
+                recommendedVramGB: 6,
+            },
+            {
+                modelName: 'Qwen2.5 0.5B',
+                size: '0.5B',
+                parameters: '0.5 billion',
+                minRamGB: 2,
+                recommendedRamGB: 4,
+                minVramGB: undefined,
+                recommendedVramGB: undefined,
+            },
+            {
+                modelName: 'Qwen2.5 7B',
+                size: '7B',
+                parameters: '7 billion',
+                minRamGB: 8,
+                recommendedRamGB: 16,
+                minVramGB: 6,
+                recommendedVramGB: 8,
+            },
+            // DeepSeek-R1 models (https://ollama.com/library/deepseek-r1)
+            {
+                modelName: 'DeepSeek-R1 1.5B',
+                size: '1.5B',
+                parameters: '1.5 billion',
+                minRamGB: 2,
+                recommendedRamGB: 4,
+                minVramGB: undefined,
+                recommendedVramGB: undefined,
+            },
+            {
+                modelName: 'DeepSeek-R1 7B',
+                size: '7B',
+                parameters: '7 billion',
+                minRamGB: 8,
+                recommendedRamGB: 16,
+                minVramGB: 6,
+                recommendedVramGB: 8,
+            },
+            {
+                modelName: 'DeepSeek-R1 8B',
+                size: '8B',
+                parameters: '8 billion',
+                minRamGB: 8,
+                recommendedRamGB: 16,
+                minVramGB: 6,
+                recommendedVramGB: 8,
+            },
+            {
+                modelName: 'DeepSeek-R1 14B',
+                size: '14B',
+                parameters: '14 billion',
+                minRamGB: 16,
+                recommendedRamGB: 32,
+                minVramGB: 10,
+                recommendedVramGB: 14,
+            },
+            {
+                modelName: 'DeepSeek-R1 32B',
+                size: '32B',
+                parameters: '32 billion',
+                minRamGB: 32,
+                recommendedRamGB: 48,
+                minVramGB: 20,
+                recommendedVramGB: 32,
+            },
+            {
+                modelName: 'DeepSeek-R1 70B',
+                size: '70B',
+                parameters: '70 billion',
+                minRamGB: 40,
+                recommendedRamGB: 64,
+                minVramGB: 40,
+                recommendedVramGB: 48,
+            },
+            {
+                modelName: 'DeepSeek-R1 671B',
+                size: '671B',
+                parameters: '671 billion',
+                minRamGB: 400,
+                recommendedRamGB: 512,
+                minVramGB: 400,
+                recommendedVramGB: 512,
+            },
+        ];
+        for (const model of models) {
+            const suitability = this.calculateSuitability(model, cpu, memory, gpu);
+            const reasoning = this.generateReasoning(model, cpu, memory, gpu, suitability);
+            recommendations.push({
+                modelName: model.modelName,
+                size: model.size,
+                parameters: model.parameters,
+                minRamGB: model.minRamGB,
+                minVramGB: model.minVramGB,
+                recommendedRamGB: model.recommendedRamGB,
+                recommendedVramGB: model.recommendedVramGB,
+                suitability,
+                reasoning,
+            });
+        }
+        // Sort by suitability (excellent first, then good, etc.)
+        const suitabilityOrder = { excellent: 0, good: 1, marginal: 2, insufficient: 3 };
+        return recommendations.sort((a, b) => suitabilityOrder[a.suitability] - suitabilityOrder[b.suitability]);
+    }
+    /**
+     * Calculate suitability for a model
+     */
+    static calculateSuitability(model, cpu, memory, gpu) {
+        // Check RAM
+        const hasMinRam = memory.totalGB >= model.minRamGB;
+        const hasRecommendedRam = memory.totalGB >= model.recommendedRamGB;
+        if (!hasMinRam) {
+            return 'insufficient';
+        }
+        // Check if it's Apple Silicon (unified memory architecture)
+        const isAppleSilicon = gpu?.vendor?.includes('Apple Silicon') || false;
+        // Check VRAM if model requires it and GPU is available
+        if (model.minVramGB && gpu) {
+            if (isAppleSilicon) {
+                // Apple Silicon uses unified memory - total RAM is available for GPU
+                // We need RAM for both system and model, so check if total RAM covers both
+                const totalRamNeeded = model.minRamGB + model.minVramGB;
+                const recommendedRamNeeded = model.recommendedRamGB + (model.recommendedVramGB || 0);
+                const hasMinTotalRam = memory.totalGB >= totalRamNeeded;
+                const hasRecommendedTotalRam = memory.totalGB >= recommendedRamNeeded;
+                if (!hasMinTotalRam) {
+                    return 'insufficient';
+                }
+                if (hasRecommendedTotalRam && cpu.cores >= 4) {
+                    return 'excellent';
+                }
+                if (hasMinTotalRam && cpu.cores >= 2) {
+                    return 'good';
+                }
+                return 'marginal';
+            }
+            else if (gpu.vramGB) {
+                // Traditional GPU with dedicated VRAM
+                const hasMinVram = gpu.vramGB >= model.minVramGB;
+                const hasRecommendedVram = model.recommendedVramGB
+                    ? gpu.vramGB >= model.recommendedVramGB
+                    : true;
+                if (!hasMinVram) {
+                    return 'insufficient';
+                }
+                if (hasRecommendedRam && hasRecommendedVram) {
+                    return 'excellent';
+                }
+                if (hasMinRam && hasMinVram) {
+                    return 'good';
+                }
+                return 'marginal';
+            }
+        }
+        // If no GPU requirement or no GPU available, check RAM and CPU
+        if (hasRecommendedRam && cpu.cores >= 4) {
+            return 'excellent';
+        }
+        if (hasMinRam && cpu.cores >= 2) {
+            return 'good';
+        }
+        return 'marginal';
+    }
+    /**
+     * Generate reasoning for recommendation
+     */
+    static generateReasoning(model, cpu, memory, gpu, suitability) {
+        const reasons = [];
+        if (suitability === 'insufficient') {
+            const isAppleSilicon = gpu?.vendor?.includes('Apple Silicon') || false;
+            if (memory.totalGB < model.minRamGB) {
+                reasons.push(`Insufficient RAM: ${memory.totalGB.toFixed(1)}GB available, ${model.minRamGB}GB minimum required`);
+            }
+            if (model.minVramGB) {
+                if (isAppleSilicon) {
+                    // Apple Silicon uses unified memory
+                    const totalRamNeeded = model.minRamGB + model.minVramGB;
+                    if (memory.totalGB < totalRamNeeded) {
+                        reasons.push(`Insufficient unified memory: ${memory.totalGB.toFixed(1)}GB available, ${totalRamNeeded}GB minimum required (RAM + VRAM)`);
+                    }
+                }
+                else if (!gpu || !gpu.vramGB || gpu.vramGB < model.minVramGB) {
+                    reasons.push(`Insufficient VRAM: ${gpu?.vramGB?.toFixed(1) || 'No GPU'}GB available, ${model.minVramGB}GB minimum required`);
+                }
+            }
+            return reasons.join('. ');
+        }
+        const isAppleSilicon = gpu?.vendor?.includes('Apple Silicon') || false;
+        if (isAppleSilicon && model.minVramGB) {
+            // Apple Silicon uses unified memory
+            const totalRamNeeded = model.minRamGB + model.minVramGB;
+            const recommendedRamNeeded = model.recommendedRamGB + (model.recommendedVramGB || 0);
+            if (memory.totalGB >= recommendedRamNeeded) {
+                reasons.push(`Unified Memory: ${memory.totalGB.toFixed(1)}GB (recommended: ${recommendedRamNeeded}GB for RAM + VRAM)`);
+            }
+            else if (memory.totalGB >= totalRamNeeded) {
+                reasons.push(`Unified Memory: ${memory.totalGB.toFixed(1)}GB (minimum: ${totalRamNeeded}GB for RAM + VRAM)`);
+            }
+        }
+        else {
+            if (memory.totalGB >= model.recommendedRamGB) {
+                reasons.push(`RAM: ${memory.totalGB.toFixed(1)}GB (recommended: ${model.recommendedRamGB}GB)`);
+            }
+            else {
+                reasons.push(`RAM: ${memory.totalGB.toFixed(1)}GB (minimum: ${model.minRamGB}GB)`);
+            }
+            if (model.recommendedVramGB && gpu?.vramGB) {
+                if (gpu.vramGB >= model.recommendedVramGB) {
+                    reasons.push(`VRAM: ${gpu.vramGB.toFixed(1)}GB (recommended: ${model.recommendedVramGB}GB)`);
+                }
+                else if (gpu.vramGB >= (model.minVramGB || 0)) {
+                    reasons.push(`VRAM: ${gpu.vramGB.toFixed(1)}GB (minimum: ${model.minVramGB}GB)`);
+                }
+            }
+            else if (model.minVramGB && !gpu) {
+                reasons.push('No GPU detected (CPU-only mode possible but slower)');
+            }
+        }
+        if (cpu.cores >= 4) {
+            reasons.push(`CPU: ${cpu.cores} cores`);
+        }
+        return reasons.join(', ');
+    }
+    /**
+     * Convert bytes to GB
+     */
+    static bytesToGB(bytes) {
+        return Math.round((bytes / (1024 * 1024 * 1024)) * 10) / 10;
+    }
+    /**
+     * Display system capabilities
+     */
+    static displayCapabilities(capabilities) {
+        console.log(chalk_1.default.blue.bold('\n🖥️  System Capabilities:\n'));
+        // CPU
+        console.log(chalk_1.default.cyan.bold('CPU:'));
+        console.log(chalk_1.default.white(`  Model: ${capabilities.cpu.model}`));
+        console.log(chalk_1.default.white(`  Cores: ${capabilities.cpu.cores}`));
+        console.log(chalk_1.default.white(`  Architecture: ${capabilities.cpu.architecture}`));
+        console.log(chalk_1.default.white(`  Speed: ${capabilities.cpu.speed.toFixed(2)} GHz\n`));
+        // Memory
+        console.log(chalk_1.default.cyan.bold('Memory:'));
+        console.log(chalk_1.default.white(`  Total: ${capabilities.memory.totalGB.toFixed(1)} GB`));
+        console.log(chalk_1.default.white(`  Used: ${capabilities.memory.usedGB.toFixed(1)} GB`));
+        console.log(chalk_1.default.white(`  Free: ${capabilities.memory.freeGB.toFixed(1)} GB\n`));
+        // GPU
+        if (capabilities.gpu) {
+            console.log(chalk_1.default.cyan.bold('GPU:'));
+            console.log(chalk_1.default.white(`  Name: ${capabilities.gpu.name}`));
+            console.log(chalk_1.default.white(`  Vendor: ${capabilities.gpu.vendor}`));
+            if (capabilities.gpu.vramGB) {
+                console.log(chalk_1.default.white(`  VRAM: ${capabilities.gpu.vramGB.toFixed(1)} GB`));
+            }
+            if (capabilities.gpu.driverVersion) {
+                console.log(chalk_1.default.white(`  Driver: ${capabilities.gpu.driverVersion}`));
+            }
+            console.log('');
+        }
+        else {
+            console.log(chalk_1.default.yellow('GPU: No dedicated GPU detected\n'));
+        }
+        // GPU Driver Support & Ollama Readiness
+        console.log(chalk_1.default.cyan.bold('GPU Driver Support:\n'));
+        const support = capabilities.gpuDriverSupport;
+        // CUDA (NVIDIA)
+        if (support.cuda.available) {
+            console.log(chalk_1.default.green('  ✓ CUDA: Available'));
+            if (support.cuda.version) {
+                console.log(chalk_1.default.gray(`    Version: ${support.cuda.version}`));
+            }
+            if (support.cuda.toolkitAvailable) {
+                console.log(chalk_1.default.gray('    Toolkit: Available'));
+            }
+        }
+        else if (capabilities.gpu?.vendor?.includes('NVIDIA')) {
+            console.log(chalk_1.default.red('  ✗ CUDA: Not available'));
+            console.log(chalk_1.default.gray('    Install NVIDIA drivers and CUDA toolkit'));
+        }
+        // ROCm (AMD)
+        if (support.rocm.available) {
+            console.log(chalk_1.default.green('  ✓ ROCm: Available'));
+            if (support.rocm.version) {
+                console.log(chalk_1.default.gray(`    Version: ${support.rocm.version}`));
+            }
+        }
+        else if (capabilities.gpu?.vendor?.includes('AMD')) {
+            console.log(chalk_1.default.yellow('  ⚠ ROCm: Not available'));
+            console.log(chalk_1.default.gray('    Install ROCm drivers for AMD GPU acceleration'));
+        }
+        // Metal (macOS)
+        if (support.metal.available) {
+            console.log(chalk_1.default.green('  ✓ Metal: Available (macOS)'));
+        }
+        // Docker GPU Support
+        console.log('');
+        if (support.dockerGpuSupport.available) {
+            console.log(chalk_1.default.green('  ✓ Docker GPU Support: Available'));
+            if (support.dockerGpuSupport.runtime) {
+                console.log(chalk_1.default.gray(`    Runtime: ${support.dockerGpuSupport.runtime}`));
+            }
+            if (support.dockerGpuSupport.nvidiaContainerRuntime) {
+                console.log(chalk_1.default.gray('    NVIDIA Container Runtime: Installed'));
+            }
+            if (support.dockerGpuSupport.nvidiaDocker) {
+                console.log(chalk_1.default.gray('    nvidia-docker: Installed (legacy)'));
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow('  ⚠ Docker GPU Support: Not detected'));
+            if (capabilities.gpu) {
+                console.log(chalk_1.default.gray('    Install nvidia-container-runtime or configure Docker for GPU access'));
+            }
+            else {
+                console.log(chalk_1.default.gray('    No GPU detected - Docker GPU support not needed'));
+            }
+        }
+        // Ollama GPU Readiness
+        console.log('');
+        if (support.ollamaGpuReady) {
+            console.log(chalk_1.default.green.bold('  ✓ Ollama GPU Ready: Yes'));
+            if (support.ollamaGpuReason) {
+                console.log(chalk_1.default.gray(`    ${support.ollamaGpuReason}`));
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow.bold('  ⚠ Ollama GPU Ready: No'));
+            if (support.ollamaGpuReason) {
+                console.log(chalk_1.default.gray(`    ${support.ollamaGpuReason}`));
+            }
+        }
+        console.log('');
+        // Overall assessment
+        if (capabilities.hasEnoughResources) {
+            console.log(chalk_1.default.green.bold('✓ System has sufficient resources for local LLM\n'));
+        }
+        else {
+            console.log(chalk_1.default.yellow.bold('⚠ System may have limited resources for local LLM\n'));
+        }
+        // Recommendations
+        console.log(chalk_1.default.blue.bold('📊 Recommended LLM Models:\n'));
+        const excellent = capabilities.recommendedModels.filter((m) => m.suitability === 'excellent');
+        const good = capabilities.recommendedModels.filter((m) => m.suitability === 'good');
+        const marginal = capabilities.recommendedModels.filter((m) => m.suitability === 'marginal');
+        const insufficient = capabilities.recommendedModels.filter((m) => m.suitability === 'insufficient');
+        if (excellent.length > 0) {
+            console.log(chalk_1.default.green.bold('Excellent Fit:'));
+            excellent.forEach((model) => {
+                console.log(chalk_1.default.green(`  ✓ ${model.modelName} (${model.size})`));
+                console.log(chalk_1.default.gray(`    ${model.reasoning}`));
+            });
+            console.log('');
+        }
+        if (good.length > 0) {
+            console.log(chalk_1.default.cyan.bold('Good Fit:'));
+            good.forEach((model) => {
+                console.log(chalk_1.default.cyan(`  • ${model.modelName} (${model.size})`));
+                console.log(chalk_1.default.gray(`    ${model.reasoning}`));
+            });
+            console.log('');
+        }
+        if (marginal.length > 0) {
+            console.log(chalk_1.default.yellow.bold('Marginal (may work but not recommended):'));
+            marginal.forEach((model) => {
+                console.log(chalk_1.default.yellow(`  ⚠ ${model.modelName} (${model.size})`));
+                console.log(chalk_1.default.gray(`    ${model.reasoning}`));
+            });
+            console.log('');
+        }
+        if (insufficient.length > 0) {
+            console.log(chalk_1.default.red.bold('Insufficient Resources:'));
+            insufficient.forEach((model) => {
+                console.log(chalk_1.default.red(`  ✗ ${model.modelName} (${model.size})`));
+                console.log(chalk_1.default.gray(`    ${model.reasoning}`));
+            });
+            console.log('');
+        }
+    }
+    /**
+     * Get summary of capabilities
+     */
+    static getCapabilitySummary(capabilities) {
+        const parts = [];
+        parts.push(`${capabilities.cpu.cores} cores`);
+        parts.push(`${capabilities.memory.totalGB.toFixed(1)}GB RAM`);
+        if (capabilities.gpu) {
+            parts.push(`${capabilities.gpu.vendor} GPU`);
+            if (capabilities.gpu.vramGB) {
+                parts.push(`${capabilities.gpu.vramGB.toFixed(1)}GB VRAM`);
+            }
+        }
+        else {
+            parts.push('No GPU');
+        }
+        const suitableModels = capabilities.recommendedModels.filter((m) => m.suitability === 'excellent' || m.suitability === 'good').length;
+        return `${parts.join(', ')} - ${suitableModels} suitable LLM models`;
+    }
+}
+exports.SystemCapabilityDetector = SystemCapabilityDetector;
+//# sourceMappingURL=SystemCapabilityDetector.js.map