plusui-native 0.2.0

package/src/doctor/detectors/webview2.js

@@ -0,0 +1,66 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+// This is a check for WebView2 headers in the expected locations
+// Currently focused on Windows as WebView2 is Windows-specific
+export async function detectWebView2() {
+  if (process.platform !== 'win32') {
+    return {
+      found: true,
+      valid: true,
+      platform: process.platform,
+      message: 'Not applicable (Windows only)'
+    };
+  }
+
+  // Check common locations
+  // By default, PlusUI looks for vendor/webview.h and friends in Core/vendor
+  // But we can also check for the SDK installation if possible, though that's harder without a project context.
+  // Instead, we can check if we can find the NuGet package installed globally or if the headers are present in a known location.
+  // Since this is a CLI tool, we might not know where the user's project is.
+  // However, for a general environment check, we might just skip deep validation or check for the Windows SDK.
+  
+  // For now, we will return a soft pass but with a note if we can't easily verify.
+  // But the request is to add it to doctor.
+  
+  // Let's check if the generic 'webview2.h' is available in a common include path if environment variables are set.
+  // Or check for a directory where we usually download dependencies.
+  
+  // Realistically, for PlusUI CLI usage, we care if the user can build.
+  // The downloading happens at the project level (or SDK level).
+  
+  // Let's return true for now but signal that we are checking "WebView2 Runtime" mostly associated with the OS.
+  const runtimeCheck = await checkWebView2Runtime();
+  
+  return {
+    found: runtimeCheck.installed,
+    version: runtimeCheck.version || 'unknown',
+    valid: runtimeCheck.installed,
+    requiredVersion: 'Any'
+  };
+}
+
+async function checkWebView2Runtime() {
+  // Simple check for the registry key often present
+  try {
+     const { execSync } = await import('child_process');
+     // PowerShell command to check registry
+     const cmd = 'powershell -Command "Get-ItemProperty -Path \'HKLM:\\SOFTWARE\\WOW6432Node\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}\' -Name pv -ErrorAction SilentlyContinue | Select-Object -ExpandProperty pv"';
+     const output = execSync(cmd, { encoding: 'utf8' }).trim();
+     
+     if (output) {
+         return { installed: true, version: output };
+     }
+     // Check current user
+     const cmdUser = 'powershell -Command "Get-ItemProperty -Path \'HKCU:\\Software\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}\' -Name pv -ErrorAction SilentlyContinue | Select-Object -ExpandProperty pv"';
+     const outputUser = execSync(cmdUser, { encoding: 'utf8' }).trim();
+     
+     if (outputUser) {
+         return { installed: true, version: outputUser };
+     }
+  } catch (e) {
+      // Ignore
+  }
+  
+  return { installed: false }; // Conservative
+}

package/src/doctor/index.js

@@ -0,0 +1,184 @@
+import { detectCMake } from './detectors/cmake.js';
+import { detectNodeJS } from './detectors/nodejs.js';
+import { detectCompiler } from './detectors/compiler.js';
+import { detectJust } from './detectors/just.js';
+import { detectWebView2 } from './detectors/webview2.js';
+import { DoctorReporter } from './reporter.js';
+import * as windowsInstaller from './installers/windows.js';
+import * as macosInstaller from './installers/macos.js';
+import * as linuxInstaller from './installers/linux.js';
+import chalk from 'chalk';
+
+export class EnvironmentDoctor {
+  constructor() {
+    this.platform = process.platform;
+    this.installer = this.getInstaller();
+  }
+
+  getInstaller() {
+    switch (this.platform) {
+      case 'win32':
+        return windowsInstaller;
+      case 'darwin':
+        return macosInstaller;
+      default:
+        return linuxInstaller;
+    }
+  }
+
+  async diagnose(options = {}) {
+    const { quick = false } = options;
+
+    console.log(chalk.bold('\nPlusUI Environment Doctor\n'));
+    console.log('Checking your development environment...\n');
+
+    // Run all detections in parallel
+    const [nodejs, cmake, compiler, just, webview2] = await Promise.all([
+      detectNodeJS(),
+      detectCMake(),
+      detectCompiler(),
+      detectJust(),
+      detectWebView2()
+    ]);
+
+    const results = {
+      platform: this.platform,
+      nodejs,
+      cmake,
+      compiler,
+      compiler,
+      just,
+      webview2,
+      hasIssues: false
+    };
+
+    // Check if there are any issues
+    results.hasIssues =
+      !nodejs.found || !nodejs.valid ||
+      !cmake.found || !cmake.valid ||
+      !compiler.found || !compiler.valid ||
+      !compiler.found || !compiler.valid ||
+      !just.found || !just.valid ||
+      !webview2.found;
+
+    return results;
+  }
+
+  async autoFix(results) {
+    console.log(chalk.bold('\nAttempting automatic installation...\n'));
+
+    const fixes = [];
+
+    // Fix Node.js if needed
+    if (!results.nodejs.found || !results.nodejs.valid) {
+      fixes.push(this.fixTool('nodejs', 'Node.js'));
+    }
+
+    // Fix CMake if needed
+    if (!results.cmake.found || !results.cmake.valid) {
+      fixes.push(this.fixTool('cmake', 'CMake'));
+    }
+
+    // Fix compiler if needed
+    if (!results.compiler.found || !results.compiler.valid) {
+      const compilerTool = this.platform === 'win32' ? 'visualstudio' :
+                          this.platform === 'darwin' ? 'xcode' : 'buildtools';
+      fixes.push(this.fixTool(compilerTool, results.compiler.name));
+    }
+
+    // Fix just if needed
+    if (!results.just.found || !results.just.valid) {
+      fixes.push(this.fixTool('just', 'Just Command Runner'));
+    }
+
+    if (!results.webview2.found && results.webview2.platform === 'win32') {
+        fixes.push(this.fixTool('webview2', 'WebView2 Runtime'));
+    }
+
+    const fixResults = await Promise.all(fixes);
+
+    // Print results
+    console.log(chalk.bold('\nInstallation Results\n'));
+    console.log('====================\n');
+
+    for (const result of fixResults) {
+      if (result.success) {
+        console.log(chalk.green(`✓ ${result.name} installed successfully`));
+      } else {
+        console.log(chalk.red(`✗ ${result.name} installation failed`));
+        if (result.message) {
+          console.log(chalk.gray(`  ${result.message}`));
+        }
+        if (result.instructions) {
+          console.log(chalk.yellow('\n  Manual installation required:'));
+          result.instructions.forEach(line => {
+            console.log(chalk.gray(`    ${line}`));
+          });
+        }
+      }
+    }
+
+    // Re-run diagnosis to verify
+    console.log(chalk.bold('\n\nVerifying installation...\n'));
+    const newResults = await this.diagnose();
+
+    return newResults;
+  }
+
+  async fixTool(toolName, displayName) {
+    try {
+      const result = await this.installer.installTool(toolName);
+      return {
+        name: displayName,
+        ...result
+      };
+    } catch (error) {
+      return {
+        name: displayName,
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async quickCheck() {
+    // Lightweight check for use in `plusui create`
+    const [cmake, compiler, just] = await Promise.all([
+      detectCMake(),
+      detectCompiler(),
+      detectJust()
+    ]);
+
+    const ready = cmake.found && cmake.valid && compiler.found && compiler.valid && just.found && just.valid;
+
+    return {
+      ready,
+      cmake,
+      compiler,
+      just
+    };
+  }
+}
+
+// Export for use in CLI
+export async function runDoctor(options = {}) {
+  const { fix = false, json = false, quick = false } = options;
+
+  const doctor = new EnvironmentDoctor();
+  const results = await doctor.diagnose({ quick });
+
+  if (json) {
+    console.log(JSON.stringify(results, null, 2));
+    return results;
+  }
+
+  const reporter = new DoctorReporter();
+  const allGood = reporter.formatResults(results);
+
+  if (fix && results.hasIssues) {
+    const fixedResults = await doctor.autoFix(results);
+    return fixedResults;
+  }
+
+  return results;
+}

package/src/doctor/installers/linux.js

@@ -0,0 +1,121 @@
+import { execSync } from 'child_process';
+
+async function tryCommand(command) {
+  try {
+    const output = execSync(command, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf8',
+      timeout: 30000
+    }).trim();
+    return { success: true, output };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+async function detectPackageManager() {
+  const managers = [
+    { name: 'apt', check: 'apt --version' },
+    { name: 'dnf', check: 'dnf --version' },
+    { name: 'pacman', check: 'pacman --version' },
+    { name: 'zypper', check: 'zypper --version' }
+  ];
+
+  for (const pm of managers) {
+    const result = await tryCommand(pm.check);
+    if (result.success) {
+      return pm.name;
+    }
+  }
+
+  return null;
+}
+
+const INSTALL_COMMANDS = {
+  apt: {
+    cmake: 'sudo apt install -y cmake',
+    buildtools: 'sudo apt install -y build-essential',
+    nodejs: 'sudo apt install -y nodejs npm'
+  },
+  dnf: {
+    cmake: 'sudo dnf install -y cmake',
+    buildtools: 'sudo dnf groupinstall -y "Development Tools"',
+    nodejs: 'sudo dnf install -y nodejs'
+  },
+  pacman: {
+    cmake: 'sudo pacman -S --noconfirm cmake',
+    buildtools: 'sudo pacman -S --noconfirm base-devel',
+    nodejs: 'sudo pacman -S --noconfirm nodejs npm'
+  },
+  zypper: {
+    cmake: 'sudo zypper install -y cmake',
+    buildtools: 'sudo zypper install -y -t pattern devel_basis',
+    nodejs: 'sudo zypper install -y nodejs npm'
+  }
+};
+
+const TOOL_NAMES = {
+  cmake: 'CMake',
+  buildtools: 'Build Tools (gcc/g++)',
+  nodejs: 'Node.js'
+};
+
+export async function installTool(toolName) {
+  const name = TOOL_NAMES[toolName] || toolName;
+  const pm = await detectPackageManager();
+
+  if (!pm) {
+    return {
+      success: false,
+      autoInstallAvailable: false,
+      message: 'Could not detect package manager (apt, dnf, pacman, zypper)',
+      instructions: [
+        `Please install ${name} manually using your distribution's package manager`
+      ]
+    };
+  }
+
+  const command = INSTALL_COMMANDS[pm]?.[toolName];
+
+  if (!command) {
+    return {
+      success: false,
+      error: `No install command for ${toolName} on ${pm}`
+    };
+  }
+
+  console.log(`Installing ${name} via ${pm}...`);
+  console.log(`Running: ${command}`);
+
+  const result = await tryCommand(command);
+
+  if (result.success) {
+    return {
+      success: true,
+      message: `${name} installed successfully`,
+      output: result.output
+    };
+  }
+
+  return {
+    success: false,
+    autoInstallAvailable: true,
+    error: result.error,
+    message: `Failed to install ${name} automatically`,
+    manualCommand: command
+  };
+}
+
+export function getInstallInstructions(toolName) {
+  const name = TOOL_NAMES[toolName] || toolName;
+
+  return {
+    name,
+    instructions: [
+      'Debian/Ubuntu: ' + (INSTALL_COMMANDS.apt[toolName] || 'N/A'),
+      'Fedora/RHEL: ' + (INSTALL_COMMANDS.dnf[toolName] || 'N/A'),
+      'Arch Linux: ' + (INSTALL_COMMANDS.pacman[toolName] || 'N/A'),
+      'openSUSE: ' + (INSTALL_COMMANDS.zypper[toolName] || 'N/A')
+    ]
+  };
+}

package/src/doctor/installers/macos.js

@@ -0,0 +1,123 @@
+import { execSync } from 'child_process';
+
+async function tryCommand(command) {
+  try {
+    const output = execSync(command, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf8',
+      timeout: 30000
+    }).trim();
+    return { success: true, output };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+async function checkHomebrew() {
+  const result = await tryCommand('brew --version');
+  return result.success;
+}
+
+const INSTALL_COMMANDS = {
+  cmake: {
+    command: 'brew install cmake',
+    manual: 'https://cmake.org/download/',
+    name: 'CMake'
+  },
+  nodejs: {
+    command: 'brew install node',
+    manual: 'https://nodejs.org/',
+    name: 'Node.js'
+  },
+  xcode: {
+    command: 'xcode-select --install',
+    manual: 'https://developer.apple.com/xcode/',
+    name: 'Xcode Command Line Tools'
+  }
+};
+
+export async function installTool(toolName) {
+  const tool = INSTALL_COMMANDS[toolName];
+
+  if (!tool) {
+    return {
+      success: false,
+      error: `Unknown tool: ${toolName}`
+    };
+  }
+
+  // For Xcode, we can always try xcode-select --install
+  if (toolName === 'xcode') {
+    console.log(`Installing ${tool.name}...`);
+    const result = await tryCommand(tool.command);
+
+    if (result.success) {
+      return {
+        success: true,
+        message: `${tool.name} installation started. Follow the prompts.`,
+        output: result.output
+      };
+    }
+
+    return {
+      success: false,
+      error: result.error,
+      message: `Failed to install ${tool.name}`,
+      manual: tool.manual
+    };
+  }
+
+  // Check if Homebrew is available
+  const hasHomebrew = await checkHomebrew();
+
+  if (!hasHomebrew) {
+    return {
+      success: false,
+      autoInstallAvailable: false,
+      manual: tool.manual,
+      message: 'Homebrew is not installed. Install Homebrew first from: https://brew.sh',
+      instructions: [
+        'Install Homebrew:',
+        '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+        '',
+        `Then install ${tool.name}:`,
+        tool.command
+      ]
+    };
+  }
+
+  // Attempt auto-installation
+  console.log(`Installing ${tool.name} via Homebrew...`);
+  const result = await tryCommand(tool.command);
+
+  if (result.success) {
+    return {
+      success: true,
+      message: `${tool.name} installed successfully`,
+      output: result.output
+    };
+  }
+
+  return {
+    success: false,
+    autoInstallAvailable: true,
+    error: result.error,
+    message: `Failed to install ${tool.name} automatically`,
+    manual: tool.manual,
+    downloadUrl: tool.manual
+  };
+}
+
+export function getInstallInstructions(toolName) {
+  const tool = INSTALL_COMMANDS[toolName];
+  if (!tool) return null;
+
+  return {
+    name: tool.name,
+    manual: tool.manual,
+    instructions: [
+      `Install via Homebrew: ${tool.command}`,
+      `Or download from: ${tool.manual}`
+    ]
+  };
+}

package/src/doctor/installers/windows.js

@@ -0,0 +1,117 @@
+import { execSync } from 'child_process';
+
+async function tryCommand(command) {
+  try {
+    const output = execSync(command, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf8',
+      timeout: 30000
+    }).trim();
+    return { success: true, output };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+async function checkWinget() {
+  const result = await tryCommand('winget --version');
+  return result.success;
+}
+
+const INSTALL_COMMANDS = {
+  cmake: {
+    command: 'winget install -e --id Kitware.CMake',
+    manual: 'https://cmake.org/download/',
+    name: 'CMake'
+  },
+  nodejs: {
+    command: 'winget install -e --id OpenJS.NodeJS',
+    manual: 'https://nodejs.org/',
+    name: 'Node.js'
+  },
+  visualstudio: {
+    command: null, // Too complex for auto-install
+    manual: 'https://visualstudio.microsoft.com/downloads/',
+    name: 'Visual Studio 2022',
+    instructions: [
+      '1. Download Visual Studio 2022 Community (free)',
+      '2. Run the installer',
+      '3. Select "Desktop development with C++" workload',
+      '4. Ensure these components are included:',
+      '   - MSVC v143 - VS 2022 C++ x64/x86 build tools',
+      '   - Windows 11 SDK (10.0.22621.0 or later)',
+      '   - CMake tools for Windows'
+    ]
+  }
+};
+
+export async function installTool(toolName) {
+  const tool = INSTALL_COMMANDS[toolName];
+
+  if (!tool) {
+    return {
+      success: false,
+      error: `Unknown tool: ${toolName}`
+    };
+  }
+
+  // Check if winget is available
+  const hasWinget = await checkWinget();
+
+  if (!hasWinget && tool.command) {
+    return {
+      success: false,
+      autoInstallAvailable: false,
+      manual: tool.manual,
+      message: 'winget is not available. Please install manually.',
+      downloadUrl: tool.manual
+    };
+  }
+
+  // If no auto-install command, provide manual instructions
+  if (!tool.command) {
+    return {
+      success: false,
+      autoInstallAvailable: false,
+      manual: tool.manual,
+      instructions: tool.instructions,
+      message: `${tool.name} requires manual installation`,
+      downloadUrl: tool.manual
+    };
+  }
+
+  // Attempt auto-installation
+  console.log(`Installing ${tool.name} via winget...`);
+  const result = await tryCommand(tool.command);
+
+  if (result.success) {
+    return {
+      success: true,
+      message: `${tool.name} installed successfully`,
+      output: result.output
+    };
+  }
+
+  return {
+    success: false,
+    autoInstallAvailable: true,
+    error: result.error,
+    message: `Failed to install ${tool.name} automatically`,
+    manual: tool.manual,
+    downloadUrl: tool.manual
+  };
+}
+
+export function getInstallInstructions(toolName) {
+  const tool = INSTALL_COMMANDS[toolName];
+  if (!tool) return null;
+
+  return {
+    name: tool.name,
+    manual: tool.manual,
+    instructions: tool.instructions || [
+      `Install via winget: ${tool.command}`,
+      `Or download from: ${tool.manual}`
+    ]
+  };
+}