vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/doctor/modules/os-quirks.js

@@ -0,0 +1,706 @@
+/**
+ * OS-Specific Quirks Diagnostics Module
+ * 
+ * Checks for known Windows/macOS/Linux-specific issues and environment problems
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync, spawnSync } = require('child_process');
+const { SEVERITY, CATEGORY, FIX_TYPE } = require('../types');
+
+const MODULE_ID = 'os';
+
+const PLATFORM = os.platform();
+const IS_WINDOWS = PLATFORM === 'win32';
+const IS_MAC = PLATFORM === 'darwin';
+const IS_LINUX = PLATFORM === 'linux';
+
+function createDiagnostics(projectPath) {
+  return [
+    // Windows-specific checks
+    ...(IS_WINDOWS ? createWindowsDiagnostics(projectPath) : []),
+    
+    // macOS-specific checks
+    ...(IS_MAC ? createMacDiagnostics(projectPath) : []),
+    
+    // Linux-specific checks
+    ...(IS_LINUX ? createLinuxDiagnostics(projectPath) : []),
+    
+    // Cross-platform checks
+    ...createCrossPlatformDiagnostics(projectPath),
+  ];
+}
+
+function createWindowsDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.win_long_paths`,
+      name: 'Windows Long Paths',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        // Check if long paths are enabled
+        try {
+          const result = execSync(
+            'reg query "HKLM\\SYSTEM\\CurrentControlSet\\Control\\FileSystem" /v LongPathsEnabled',
+            { encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
+          );
+          
+          const enabled = result.includes('0x1');
+          
+          if (!enabled) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: 'Long paths not enabled',
+              detail: 'node_modules paths can exceed 260 char limit',
+              metadata: { longPathsEnabled: false },
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Enable long paths (requires admin)',
+                command: 'reg add "HKLM\\SYSTEM\\CurrentControlSet\\Control\\FileSystem" /v LongPathsEnabled /t REG_DWORD /d 1 /f',
+                dangerous: true,
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Long paths enabled',
+            metadata: { longPathsEnabled: true },
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check long path setting',
+            detail: err.message,
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.win_execution_policy`,
+      name: 'PowerShell Execution Policy',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        try {
+          const policy = execSync('powershell -Command Get-ExecutionPolicy', {
+            encoding: 'utf8',
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          const metadata = { executionPolicy: policy };
+          
+          if (policy === 'Restricted') {
+            return {
+              severity: SEVERITY.ERROR,
+              message: `ExecutionPolicy: ${policy}`,
+              detail: 'Scripts cannot run, breaking npm scripts',
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Set RemoteSigned policy (recommended)',
+                command: 'Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          if (policy === 'AllSigned') {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `ExecutionPolicy: ${policy}`,
+              detail: 'May require script signing for some npm packages',
+              metadata,
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `ExecutionPolicy: ${policy}`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check execution policy',
+            detail: err.message,
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.win_line_endings`,
+      name: 'Git Line Endings',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        try {
+          const autocrlf = execSync('git config --global core.autocrlf', {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          const metadata = { autocrlf };
+          
+          if (autocrlf === 'true') {
+            return {
+              severity: SEVERITY.PASS,
+              message: 'autocrlf=true (Windows recommended)',
+              metadata,
+            };
+          }
+          
+          if (autocrlf === 'input' || autocrlf === 'false') {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `autocrlf=${autocrlf}`,
+              detail: 'May cause line ending issues on Windows',
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Set autocrlf to true',
+                command: 'git config --global core.autocrlf true',
+                autoFixable: true,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.INFO,
+            message: 'autocrlf not set',
+            metadata,
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Set autocrlf to true',
+              command: 'git config --global core.autocrlf true',
+              autoFixable: true,
+            }],
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check git config',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.win_antivirus`,
+      name: 'Antivirus Exclusions',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        // Check if Windows Defender is active
+        try {
+          const result = execSync(
+            'powershell -Command "(Get-MpPreference).ExclusionPath"',
+            { encoding: 'utf8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] }
+          );
+          
+          const exclusions = result.trim().split('\n').filter(Boolean);
+          const hasNodeExclusion = exclusions.some(e => 
+            e.includes('node_modules') || 
+            e.includes(projectPath) ||
+            e.includes('npm') ||
+            e.includes('pnpm')
+          );
+          
+          const metadata = { defenderExclusions: exclusions.length, hasNodeExclusion };
+          
+          if (!hasNodeExclusion) {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'node_modules not excluded from Defender',
+              detail: 'May slow down npm install significantly',
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Add node_modules to Defender exclusions (admin)',
+                command: `Add-MpPreference -ExclusionPath "${path.join(projectPath, 'node_modules')}"`,
+                dangerous: true,
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Defender exclusions configured',
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check Defender exclusions',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.win_symlinks`,
+      name: 'Symlink Support',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        // Check if user can create symlinks
+        const testPath = path.join(os.tmpdir(), `.vibecheck-symlink-test-${Date.now()}`);
+        const targetPath = path.join(os.tmpdir(), `.vibecheck-symlink-target-${Date.now()}`);
+        
+        try {
+          fs.writeFileSync(targetPath, 'test');
+          fs.symlinkSync(targetPath, testPath);
+          fs.unlinkSync(testPath);
+          fs.unlinkSync(targetPath);
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Symlink creation OK',
+            metadata: { canCreateSymlinks: true },
+          };
+        } catch (err) {
+          // Clean up
+          try { fs.unlinkSync(targetPath); } catch {}
+          
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Cannot create symlinks',
+            detail: 'Some packages may fail. Enable Developer Mode or run as admin.',
+            metadata: { canCreateSymlinks: false },
+            fixes: [{
+              type: FIX_TYPE.MANUAL,
+              description: 'Enable Developer Mode in Windows Settings > Update & Security > For developers',
+              autoFixable: false,
+            }],
+          };
+        }
+      },
+    },
+  ];
+}
+
+function createMacDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.mac_xcode_tools`,
+      name: 'Xcode Command Line Tools',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        try {
+          execSync('xcode-select -p', {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Xcode CLI tools installed',
+            metadata: { installed: true },
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'Xcode CLI tools not installed',
+            detail: 'Required for native module compilation',
+            metadata: { installed: false },
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Install Xcode Command Line Tools',
+              command: 'xcode-select --install',
+              autoFixable: false,
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.mac_homebrew`,
+      name: 'Homebrew',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        try {
+          const version = execSync('brew --version', {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).split('\n')[0];
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: version,
+            metadata: { installed: true, version },
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Homebrew not installed',
+            metadata: { installed: false },
+            fixes: [{
+              type: FIX_TYPE.LINK,
+              description: 'Install Homebrew',
+              url: 'https://brew.sh/',
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.mac_file_limit`,
+      name: 'Open File Limit',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        try {
+          const limit = execSync('ulimit -n', {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          const numLimit = parseInt(limit);
+          const metadata = { fileLimit: numLimit };
+          
+          if (numLimit < 1024) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `File limit: ${limit} (too low)`,
+              detail: 'May cause "too many open files" errors',
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Increase file limit',
+                command: 'ulimit -n 10240',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `File limit: ${limit}`,
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check file limit',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.mac_rosetta`,
+      name: 'Rosetta 2 (Apple Silicon)',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        // Check if running on Apple Silicon
+        const arch = os.arch();
+        if (arch !== 'arm64') {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Intel Mac (Rosetta not needed)',
+            metadata: { arch, appleSlicon: false },
+          };
+        }
+        
+        // Check if Rosetta is installed
+        try {
+          const result = execSync('arch -x86_64 /usr/bin/true 2>&1 || echo "not installed"', {
+            encoding: 'utf8',
+            timeout: 5000,
+            shell: '/bin/bash',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          
+          if (result.includes('not installed')) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: 'Rosetta 2 not installed',
+              detail: 'Some x86 packages may not work',
+              metadata: { arch, rosettaInstalled: false },
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Install Rosetta 2',
+                command: 'softwareupdate --install-rosetta --agree-to-license',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Apple Silicon with Rosetta 2',
+            metadata: { arch, rosettaInstalled: true },
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check Rosetta status',
+            metadata: { arch },
+          };
+        }
+      },
+    },
+  ];
+}
+
+function createLinuxDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.linux_build_essential`,
+      name: 'Build Essentials',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        // Check for common build tools
+        const tools = ['gcc', 'g++', 'make'];
+        const missing = [];
+        
+        for (const tool of tools) {
+          try {
+            execSync(`which ${tool}`, {
+              encoding: 'utf8',
+              timeout: 5000,
+              stdio: ['pipe', 'pipe', 'pipe'],
+            });
+          } catch {
+            missing.push(tool);
+          }
+        }
+        
+        const metadata = { missing, checked: tools };
+        
+        if (missing.length > 0) {
+          // Detect package manager
+          let installCmd = 'sudo apt install -y build-essential';
+          try {
+            execSync('which dnf', { stdio: ['pipe', 'pipe', 'pipe'] });
+            installCmd = 'sudo dnf groupinstall "Development Tools"';
+          } catch {
+            try {
+              execSync('which yum', { stdio: ['pipe', 'pipe', 'pipe'] });
+              installCmd = 'sudo yum groupinstall "Development Tools"';
+            } catch {
+              try {
+                execSync('which pacman', { stdio: ['pipe', 'pipe', 'pipe'] });
+                installCmd = 'sudo pacman -S base-devel';
+              } catch {}
+            }
+          }
+          
+          return {
+            severity: SEVERITY.ERROR,
+            message: `Missing: ${missing.join(', ')}`,
+            detail: 'Required for native module compilation',
+            metadata,
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Install build tools',
+              command: installCmd,
+              autoFixable: false,
+            }],
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: 'Build tools available',
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.linux_inotify`,
+      name: 'inotify Watches',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        try {
+          const maxWatches = execSync('cat /proc/sys/fs/inotify/max_user_watches', {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          const numWatches = parseInt(maxWatches);
+          const metadata = { maxUserWatches: numWatches };
+          
+          if (numWatches < 65536) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `inotify watches: ${numWatches} (low)`,
+              detail: 'File watchers may fail with "ENOSPC" error',
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Increase inotify limit',
+                command: 'echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `inotify watches: ${numWatches}`,
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check inotify limit',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.linux_distro`,
+      name: 'Linux Distribution',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        try {
+          const releaseFile = fs.existsSync('/etc/os-release') 
+            ? '/etc/os-release' 
+            : '/etc/lsb-release';
+          
+          const content = fs.readFileSync(releaseFile, 'utf8');
+          const lines = content.split('\n');
+          
+          let name = 'Unknown';
+          let version = '';
+          
+          for (const line of lines) {
+            if (line.startsWith('PRETTY_NAME=')) {
+              name = line.split('=')[1].replace(/"/g, '');
+            } else if (line.startsWith('VERSION_ID=')) {
+              version = line.split('=')[1].replace(/"/g, '');
+            }
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: name,
+            metadata: { name, version },
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not detect distribution',
+          };
+        }
+      },
+    },
+  ];
+}
+
+function createCrossPlatformDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.git_installed`,
+      name: 'Git Installation',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        try {
+          const version = execSync('git --version', {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          const match = version.match(/git version (\d+\.\d+\.\d+)/);
+          const versionNum = match ? match[1] : version;
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: versionNum,
+            metadata: { version: versionNum },
+          };
+        } catch {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'Git not installed',
+            fixes: [{
+              type: FIX_TYPE.LINK,
+              description: 'Install Git',
+              url: 'https://git-scm.com/downloads',
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.env_variables`,
+      name: 'Environment Variables',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        const important = [
+          { name: 'HOME', required: !IS_WINDOWS },
+          { name: 'USERPROFILE', required: IS_WINDOWS },
+          { name: 'PATH', required: true },
+          { name: 'TERM', required: false },
+          { name: 'EDITOR', required: false },
+        ];
+        
+        const missing = [];
+        const present = [];
+        
+        for (const env of important) {
+          const value = process.env[env.name];
+          if (value) {
+            present.push(env.name);
+          } else if (env.required) {
+            missing.push(env.name);
+          }
+        }
+        
+        const metadata = { present, missing };
+        
+        if (missing.length > 0) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: `Missing: ${missing.join(', ')}`,
+            metadata,
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `${present.length} key variables set`,
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.timezone`,
+      name: 'Timezone',
+      category: CATEGORY.SYSTEM,
+      parallel: true,
+      check: async () => {
+        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const offset = new Date().getTimezoneOffset();
+        const offsetHours = -offset / 60;
+        const offsetStr = `UTC${offsetHours >= 0 ? '+' : ''}${offsetHours}`;
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `${tz} (${offsetStr})`,
+          metadata: { timezone: tz, offsetMinutes: offset, offsetStr },
+        };
+      },
+    },
+  ];
+}
+
+module.exports = { MODULE_ID, createDiagnostics };