auto-dev-setup 0.1.0

package/src/platform/detector.js

@@ -0,0 +1,240 @@
+/**
+ * Platform Detection Module
+ * Detects OS, CPU architecture, and default shell
+ */
+
+const os = require('os');
+const { execSync } = require('child_process');
+
+/**
+ * Detect the operating system
+ * @returns {Object} OS information
+ */
+function detectOS() {
+  const platform = process.platform;
+
+  const osMap = {
+    darwin: {
+      name: 'macOS',
+      platform: 'darwin',
+      packageManager: 'brew',
+      icon: '🍎'
+    },
+    linux: {
+      name: 'Linux',
+      platform: 'linux',
+      packageManager: detectLinuxPackageManager(),
+      distro: detectLinuxDistro(),
+      icon: '🐧'
+    },
+    win32: {
+      name: 'Windows',
+      platform: 'win32',
+      packageManager: detectWindowsPackageManager(),
+      icon: '🪟'
+    }
+  };
+
+  return osMap[platform] || {
+    name: 'Unknown',
+    platform: platform,
+    packageManager: null,
+    icon: '❓'
+  };
+}
+
+/**
+ * Detect Linux distribution
+ * @returns {string} Distribution name
+ */
+function detectLinuxDistro() {
+  if (process.platform !== 'linux') return null;
+
+  try {
+    // Try to read /etc/os-release
+    const osRelease = require('fs').readFileSync('/etc/os-release', 'utf8');
+    const idMatch = osRelease.match(/^ID=(.*)$/m);
+    if (idMatch) {
+      return idMatch[1].replace(/"/g, '').toLowerCase();
+    }
+  } catch {
+    // Fallback to checking package managers
+    try {
+      execSync('which apt', { stdio: 'pipe' });
+      return 'debian';
+    } catch {
+      try {
+        execSync('which dnf', { stdio: 'pipe' });
+        return 'fedora';
+      } catch {
+        try {
+          execSync('which pacman', { stdio: 'pipe' });
+          return 'arch';
+        } catch {
+          return 'unknown';
+        }
+      }
+    }
+  }
+  return 'unknown';
+}
+
+/**
+ * Detect Linux package manager
+ * @returns {string} Package manager command
+ */
+function detectLinuxPackageManager() {
+  if (process.platform !== 'linux') return null;
+
+  const managers = [
+    { cmd: 'apt', name: 'apt' },
+    { cmd: 'dnf', name: 'dnf' },
+    { cmd: 'yum', name: 'yum' },
+    { cmd: 'pacman', name: 'pacman' },
+    { cmd: 'zypper', name: 'zypper' },
+    { cmd: 'apk', name: 'apk' }
+  ];
+
+  for (const manager of managers) {
+    try {
+      execSync(`which ${manager.cmd}`, { stdio: 'pipe' });
+      return manager.name;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+/**
+ * Detect Windows package manager
+ * @returns {string} Package manager command
+ */
+function detectWindowsPackageManager() {
+  if (process.platform !== 'win32') return null;
+
+  try {
+    execSync('winget --version', { stdio: 'pipe' });
+    return 'winget';
+  } catch {
+    try {
+      execSync('choco --version', { stdio: 'pipe' });
+      return 'choco';
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Detect CPU architecture
+ * @returns {Object} Architecture information
+ */
+function detectArchitecture() {
+  const arch = process.arch;
+  const cpus = os.cpus();
+
+  const archMap = {
+    x64: 'x86_64 (64-bit)',
+    arm64: 'ARM64 (Apple Silicon / ARM)',
+    arm: 'ARM (32-bit)',
+    ia32: 'x86 (32-bit)'
+  };
+
+  return {
+    arch: arch,
+    display: archMap[arch] || arch,
+    cpuModel: cpus.length > 0 ? cpus[0].model : 'Unknown',
+    cores: cpus.length
+  };
+}
+
+/**
+ * Detect default shell
+ * @returns {Object} Shell information
+ */
+function detectShell() {
+  const platform = process.platform;
+  let shell = process.env.SHELL || '';
+  let configFile = '';
+
+  if (platform === 'win32') {
+    // Windows shell detection
+    if (process.env.PSModulePath) {
+      shell = 'powershell';
+      configFile = '$PROFILE';
+    } else {
+      shell = 'cmd';
+      configFile = 'N/A';
+    }
+  } else {
+    // Unix-like shell detection
+    const shellName = shell.split('/').pop();
+
+    const configFiles = {
+      zsh: '~/.zshrc',
+      bash: '~/.bashrc',
+      fish: '~/.config/fish/config.fish',
+      sh: '~/.profile'
+    };
+
+    configFile = configFiles[shellName] || '~/.profile';
+    shell = shellName;
+  }
+
+  return {
+    name: shell,
+    path: process.env.SHELL || 'N/A',
+    configFile: configFile
+  };
+}
+
+/**
+ * Check if running with elevated privileges
+ * @returns {boolean} True if admin/root
+ */
+function isElevated() {
+  if (process.platform === 'win32') {
+    try {
+      execSync('net session', { stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  } else {
+    return process.getuid && process.getuid() === 0;
+  }
+}
+
+/**
+ * Get complete platform information
+ * @returns {Object} Complete platform details
+ */
+function getPlatformInfo() {
+  const osInfo = detectOS();
+  const archInfo = detectArchitecture();
+  const shellInfo = detectShell();
+
+  return {
+    os: osInfo,
+    architecture: archInfo,
+    shell: shellInfo,
+    hostname: os.hostname(),
+    username: os.userInfo().username,
+    homedir: os.homedir(),
+    isElevated: isElevated(),
+    nodeVersion: process.version,
+    platform: process.platform
+  };
+}
+
+module.exports = {
+  detectOS,
+  detectArchitecture,
+  detectShell,
+  detectLinuxDistro,
+  detectLinuxPackageManager,
+  detectWindowsPackageManager,
+  isElevated,
+  getPlatformInfo
+};

package/src/platform/index.js

@@ -0,0 +1,36 @@
+/**
+ * Platform Index
+ * Central export for platform modules
+ */
+
+const detector = require('./detector');
+const macos = require('./macos');
+const linux = require('./linux');
+const windows = require('./windows');
+
+/**
+ * Get the appropriate platform module
+ * @returns {Object} Platform-specific module
+ */
+function getPlatformModule() {
+  const platform = process.platform;
+
+  switch (platform) {
+    case 'darwin':
+      return macos;
+    case 'linux':
+      return linux;
+    case 'win32':
+      return windows;
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+module.exports = {
+  detector,
+  macos,
+  linux,
+  windows,
+  getPlatformModule
+};

package/src/platform/linux.js

@@ -0,0 +1,412 @@
+/**
+ * Linux Platform Installer
+ * Handles Linux-specific installations
+ */
+
+const { execCommand, execSilent, commandExists } = require('../utils/executor');
+const logger = require('../utils/logger');
+const { detectLinuxDistro, detectLinuxPackageManager } = require('./detector');
+const ora = require('ora');
+
+/**
+ * Get the appropriate install command for the detected package manager
+ * @param {string} packageManager - Package manager name
+ * @param {string} packageName - Package to install
+ * @returns {string} Install command
+ */
+function getInstallCommand(packageManager, packageName) {
+  const commands = {
+    apt: `sudo apt-get install -y ${packageName}`,
+    dnf: `sudo dnf install -y ${packageName}`,
+    yum: `sudo yum install -y ${packageName}`,
+    pacman: `sudo pacman -S --noconfirm ${packageName}`,
+    zypper: `sudo zypper install -y ${packageName}`,
+    apk: `sudo apk add ${packageName}`
+  };
+
+  return commands[packageManager] || null;
+}
+
+/**
+ * Get package name mapping for different distros
+ * @param {string} packageManager - Package manager
+ * @param {string} genericName - Generic package name
+ * @returns {string} Distro-specific package name
+ */
+function getPackageName(packageManager, genericName) {
+  const packageMap = {
+    nodejs: {
+      apt: 'nodejs',
+      dnf: 'nodejs',
+      pacman: 'nodejs',
+      zypper: 'nodejs',
+      apk: 'nodejs'
+    },
+    npm: {
+      apt: 'npm',
+      dnf: 'npm',
+      pacman: 'npm',
+      zypper: 'npm',
+      apk: 'npm'
+    },
+    python: {
+      apt: 'python3',
+      dnf: 'python3',
+      pacman: 'python',
+      zypper: 'python3',
+      apk: 'python3'
+    },
+    pip: {
+      apt: 'python3-pip',
+      dnf: 'python3-pip',
+      pacman: 'python-pip',
+      zypper: 'python3-pip',
+      apk: 'py3-pip'
+    },
+    java: {
+      apt: 'openjdk-17-jdk',
+      dnf: 'java-17-openjdk-devel',
+      pacman: 'jdk-openjdk',
+      zypper: 'java-17-openjdk-devel',
+      apk: 'openjdk17'
+    },
+    vscode: {
+      apt: 'code',
+      dnf: 'code',
+      pacman: 'code',
+      zypper: 'code',
+      apk: 'code'
+    }
+  };
+
+  return packageMap[genericName]?.[packageManager] || genericName;
+}
+
+/**
+ * Update package manager cache
+ * @param {string} packageManager - Package manager
+ * @returns {Object} Result
+ */
+async function updatePackageCache(packageManager) {
+  logger.step('Updating package cache...');
+
+  const commands = {
+    apt: 'sudo apt-get update',
+    dnf: 'sudo dnf check-update || true',
+    yum: 'sudo yum check-update || true',
+    pacman: 'sudo pacman -Sy',
+    zypper: 'sudo zypper refresh',
+    apk: 'sudo apk update'
+  };
+
+  const command = commands[packageManager];
+  if (!command) {
+    logger.warn(`Unknown package manager: ${packageManager}`);
+    return { success: false };
+  }
+
+  const result = execCommand(command, { silent: true });
+  return result;
+}
+
+/**
+ * Install a package using the system package manager
+ * @param {string} packageName - Package to install
+ * @param {string} displayName - Display name for logging
+ * @returns {Object} Installation result
+ */
+async function installPackage(packageName, displayName = null) {
+  const name = displayName || packageName;
+  const packageManager = detectLinuxPackageManager();
+
+  if (!packageManager) {
+    logger.error('No supported package manager found');
+    return { success: false, skipped: false };
+  }
+
+  logger.step(`Checking ${name}...`);
+
+  // Check if already installed
+  if (commandExists(packageName)) {
+    logger.success(`${name} already installed`);
+    return { success: true, skipped: true };
+  }
+
+  const distroPackage = getPackageName(packageManager, packageName);
+  const command = getInstallCommand(packageManager, distroPackage);
+
+  if (!command) {
+    logger.error(`Unsupported package manager: ${packageManager}`);
+    return { success: false, skipped: false };
+  }
+
+  logger.step(`Installing ${name}...`);
+  const result = execCommand(command);
+
+  if (result.success) {
+    logger.success(`${name} installed successfully`);
+    return { success: true, skipped: false };
+  } else {
+    logger.error(`Failed to install ${name}`);
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install Git
+ */
+async function installGit() {
+  return installPackage('git', 'Git');
+}
+
+/**
+ * Install curl
+ */
+async function installCurl() {
+  return installPackage('curl', 'curl');
+}
+
+/**
+ * Install Node.js and npm
+ */
+async function installNode() {
+  const packageManager = detectLinuxPackageManager();
+
+  // For apt-based systems, use NodeSource repository for latest LTS
+  if (packageManager === 'apt') {
+    logger.step('Setting up NodeSource repository for Node.js LTS...');
+
+    // Check if Node.js is already installed
+    if (commandExists('node')) {
+      logger.success('Node.js already installed');
+      return { success: true, skipped: true };
+    }
+
+    // Install curl first if needed
+    if (!commandExists('curl')) {
+      await installCurl();
+    }
+
+    // Add NodeSource repository
+    const setupResult = execCommand(
+      'curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -'
+    );
+
+    if (!setupResult.success) {
+      logger.warn('Failed to set up NodeSource repository, using system Node.js');
+    }
+
+    return installPackage('nodejs', 'Node.js');
+  }
+
+  // For other package managers, install directly
+  const nodeResult = await installPackage('nodejs', 'Node.js');
+  const npmResult = await installPackage('npm', 'npm');
+
+  return {
+    success: nodeResult.success && npmResult.success,
+    skipped: nodeResult.skipped && npmResult.skipped
+  };
+}
+
+/**
+ * Install Visual Studio Code
+ */
+async function installVSCode() {
+  const packageManager = detectLinuxPackageManager();
+
+  logger.step('Checking Visual Studio Code...');
+
+  if (commandExists('code')) {
+    logger.success('Visual Studio Code already installed');
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing Visual Studio Code...');
+
+  if (packageManager === 'apt') {
+    // Add Microsoft repository for Debian/Ubuntu
+    execCommand(
+      'wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/packages.microsoft.gpg'
+    );
+    execCommand(
+      'sudo install -D -o root -g root -m 644 /tmp/packages.microsoft.gpg /etc/apt/keyrings/packages.microsoft.gpg'
+    );
+    execCommand(
+      'sudo sh -c \'echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/keyrings/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list\''
+    );
+    execCommand('sudo apt-get update');
+    return installPackage('code', 'Visual Studio Code');
+  } else if (packageManager === 'dnf' || packageManager === 'yum') {
+    // Add Microsoft repository for Fedora/RHEL
+    execCommand('sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc');
+    execCommand(
+      'sudo sh -c \'echo -e "[code]\\nname=Visual Studio Code\\nbaseurl=https://packages.microsoft.com/yumrepos/vscode\\nenabled=1\\ngpgcheck=1\\ngpgkey=https://packages.microsoft.com/keys/microsoft.asc" > /etc/yum.repos.d/vscode.repo\''
+    );
+    return installPackage('code', 'Visual Studio Code');
+  } else if (packageManager === 'pacman') {
+    // For Arch, use yay or install from AUR
+    if (commandExists('yay')) {
+      const result = execCommand('yay -S --noconfirm visual-studio-code-bin');
+      if (result.success) {
+        logger.success('Visual Studio Code installed successfully');
+        return { success: true, skipped: false };
+      }
+    }
+    logger.warn(
+      'Please install Visual Studio Code from AUR: yay -S visual-studio-code-bin'
+    );
+    return { success: false, skipped: false };
+  }
+
+  logger.warn('Please install Visual Studio Code manually from https://code.visualstudio.com/');
+  return { success: false, skipped: false };
+}
+
+/**
+ * Enable VS Code CLI
+ */
+async function enableVSCodeCli() {
+  // On Linux, VS Code CLI should be available after installation
+  if (commandExists('code')) {
+    logger.success('VS Code CLI already available');
+    return { success: true, skipped: true };
+  }
+  return { success: false, skipped: false };
+}
+
+/**
+ * Install Python
+ */
+async function installPython() {
+  const pythonResult = await installPackage('python3', 'Python');
+  const pipResult = await installPackage('python3-pip', 'pip');
+
+  return {
+    success: pythonResult.success && pipResult.success,
+    skipped: pythonResult.skipped && pipResult.skipped
+  };
+}
+
+/**
+ * Install Java (OpenJDK)
+ */
+async function installJava() {
+  const packageManager = detectLinuxPackageManager();
+  const javaPackage = getPackageName(packageManager, 'java');
+
+  const result = await installPackage(javaPackage, 'OpenJDK');
+
+  if (result.success && !result.skipped) {
+    // Set JAVA_HOME
+    logger.step('Configuring JAVA_HOME...');
+
+    const javaPath = execSilent('dirname $(dirname $(readlink -f $(which java)))');
+    if (javaPath.success && javaPath.output) {
+      const shellConfig = process.env.SHELL?.includes('zsh')
+        ? '~/.zshrc'
+        : '~/.bashrc';
+      execCommand(
+        `echo 'export JAVA_HOME="${javaPath.output}"' >> ${shellConfig}`
+      );
+      logger.success('JAVA_HOME configured');
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Install core build tools
+ */
+async function installBuildTools() {
+  const packageManager = detectLinuxPackageManager();
+
+  logger.step('Installing core build tools...');
+
+  const buildPackages = {
+    apt: 'build-essential',
+    dnf: '@development-tools',
+    pacman: 'base-devel',
+    zypper: '-t pattern devel_basis',
+    apk: 'build-base'
+  };
+
+  const pkg = buildPackages[packageManager];
+  if (!pkg) return { success: true, skipped: true };
+
+  const command = getInstallCommand(packageManager, pkg);
+  const result = execCommand(command);
+
+  return result;
+}
+
+/**
+ * Run base system setup for Linux
+ */
+async function setupBase() {
+  const results = {
+    installed: [],
+    skipped: [],
+    failed: []
+  };
+
+  const packageManager = detectLinuxPackageManager();
+  if (!packageManager) {
+    logger.error('No supported package manager detected');
+    return results;
+  }
+
+  logger.info(`Detected package manager: ${packageManager}`);
+
+  // Update package cache
+  await updatePackageCache(packageManager);
+
+  // Install build tools
+  const buildResult = await installBuildTools();
+  if (buildResult.success) {
+    results.installed.push('Build Tools');
+  }
+
+  // Install Git
+  const gitResult = await installGit();
+  if (gitResult.success) {
+    (gitResult.skipped ? results.skipped : results.installed).push('Git');
+  } else {
+    results.failed.push('Git');
+  }
+
+  // Install curl
+  const curlResult = await installCurl();
+  if (curlResult.success) {
+    (curlResult.skipped ? results.skipped : results.installed).push('curl');
+  } else {
+    results.failed.push('curl');
+  }
+
+  // Install wget
+  const wgetResult = await installPackage('wget', 'wget');
+  if (wgetResult.success) {
+    (wgetResult.skipped ? results.skipped : results.installed).push('wget');
+  } else {
+    results.failed.push('wget');
+  }
+
+  return results;
+}
+
+module.exports = {
+  getInstallCommand,
+  getPackageName,
+  updatePackageCache,
+  installPackage,
+  installGit,
+  installCurl,
+  installNode,
+  installVSCode,
+  enableVSCodeCli,
+  installPython,
+  installJava,
+  installBuildTools,
+  setupBase
+};