auto-dev-setup 0.1.0

package/src/stacks/python.js

@@ -0,0 +1,433 @@
+/**
+ * Python Stack Installer
+ * Installs Python, pip, pipx, virtualenv, Jupyter, NumPy, Pandas
+ */
+
+const { getPlatformModule } = require('../platform');
+const { execCommand, commandExists, getVersion } = require('../utils/executor');
+const logger = require('../utils/logger');
+const { verifyPythonStack, displayVerification } = require('../utils/verifier');
+const { VSCODE_EXTENSIONS } = require('../config/extensions');
+const { installVSCodeExtensions } = require('./web');
+
+/**
+ * Get the Python and pip commands for the current platform
+ * @returns {Object} Python command names
+ */
+function getPythonCommands() {
+  const platform = process.platform;
+
+  if (platform === 'win32') {
+    return {
+      python: 'python',
+      pip: 'pip'
+    };
+  }
+
+  // On Unix, prefer python3/pip3
+  return {
+    python: commandExists('python3') ? 'python3' : 'python',
+    pip: commandExists('pip3') ? 'pip3' : 'pip'
+  };
+}
+
+/**
+ * Check if a Python package is installed
+ * @param {string} packageName - Package name to check
+ * @returns {boolean} True if installed
+ */
+function isPythonPackageInstalled(packageName) {
+  const { python } = getPythonCommands();
+  const result = execCommand(
+    `${python} -c "import ${packageName}" 2>&1`,
+    { silent: true, showCommand: false }
+  );
+  return result.success;
+}
+
+/**
+ * Check if a pip package is installed (for CLI tools)
+ * @param {string} packageName - Package name to check
+ * @returns {boolean} True if installed
+ */
+function isPipPackageInstalled(packageName) {
+  const { pip } = getPythonCommands();
+  const result = execCommand(
+    `${pip} show ${packageName}`,
+    { silent: true, showCommand: false }
+  );
+  return result.success;
+}
+
+/**
+ * Install pipx
+ * @param {string} pipCmd - pip command to use
+ * @returns {Object} Installation result
+ */
+async function installPipx(pipCmd) {
+  logger.step('Checking pipx...');
+
+  // Check if pipx is installed as a package
+  if (isPipPackageInstalled('pipx') || commandExists('pipx')) {
+    logger.success('pipx already installed');
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing pipx...');
+
+  const result = execCommand(`${pipCmd} install --user pipx`);
+
+  if (result.success) {
+    // Ensure pipx path is set
+    execCommand('python3 -m pipx ensurepath 2>/dev/null || python -m pipx ensurepath 2>/dev/null', {
+      silent: true,
+      showCommand: false
+    });
+    logger.success('pipx installed');
+    return { success: true, skipped: false };
+  } else {
+    logger.error('Failed to install pipx');
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install virtualenv
+ * @param {string} pipCmd - pip command to use
+ * @returns {Object} Installation result
+ */
+async function installVirtualenv(pipCmd) {
+  logger.step('Checking virtualenv...');
+
+  // Check if virtualenv is installed as a package
+  if (isPipPackageInstalled('virtualenv') || commandExists('virtualenv')) {
+    logger.success('virtualenv already installed');
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing virtualenv...');
+
+  const result = execCommand(`${pipCmd} install --user virtualenv`);
+
+  if (result.success) {
+    logger.success('virtualenv installed');
+    return { success: true, skipped: false };
+  } else {
+    logger.error('Failed to install virtualenv');
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install Jupyter Notebook
+ * @param {string} pipCmd - pip command to use
+ * @returns {Object} Installation result
+ */
+async function installJupyter(pipCmd) {
+  logger.step('Checking Jupyter Notebook...');
+
+  // Check if jupyter is installed as a package
+  if (isPipPackageInstalled('jupyter') || commandExists('jupyter')) {
+    logger.success('Jupyter already installed');
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing Jupyter Notebook...');
+
+  // Use pipx if available, otherwise pip
+  let result;
+  if (commandExists('pipx')) {
+    result = execCommand('pipx install jupyter');
+  } else {
+    result = execCommand(`${pipCmd} install --user jupyter`);
+  }
+
+  if (result.success) {
+    logger.success('Jupyter Notebook installed');
+    return { success: true, skipped: false };
+  } else {
+    logger.error('Failed to install Jupyter Notebook');
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install NumPy and Pandas
+ * @param {string} pipCmd - pip command to use
+ * @returns {Object} Installation result
+ */
+async function installDataScienceLibs(pipCmd) {
+  logger.step('Checking NumPy and Pandas...');
+
+  // Check if already installed
+  const numpyInstalled = isPythonPackageInstalled('numpy');
+  const pandasInstalled = isPythonPackageInstalled('pandas');
+
+  if (numpyInstalled && pandasInstalled) {
+    logger.success('NumPy and Pandas already installed');
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing NumPy and Pandas...');
+
+  let numpyResult = { success: true };
+  let pandasResult = { success: true };
+
+  if (!numpyInstalled) {
+    numpyResult = execCommand(`${pipCmd} install --user numpy`, { silent: true });
+  }
+  if (!pandasInstalled) {
+    pandasResult = execCommand(`${pipCmd} install --user pandas`, { silent: true });
+  }
+
+  if (numpyResult.success && pandasResult.success) {
+    logger.success('NumPy and Pandas installed');
+    return { success: true, skipped: false };
+  } else {
+    logger.warn('Some data science libraries may have failed to install');
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Configure Python PATH and aliases
+ */
+async function configurePythonPath() {
+  const platform = process.platform;
+
+  if (platform === 'win32') {
+    // Windows: Add Python Scripts to PATH
+    logger.step('Configuring Python PATH for Windows...');
+    const { python } = getPythonCommands();
+
+    // Get the correct user scripts directory using sysconfig
+    const scriptsResult = execCommand(
+      `${python} -c "import sysconfig; print(sysconfig.get_path('scripts', 'nt_user'))"`,
+      { silent: true, showCommand: false }
+    );
+
+    if (scriptsResult.success && scriptsResult.output) {
+      const scriptsDir = scriptsResult.output.trim();
+
+      logger.info(`Python user scripts directory: ${scriptsDir}`);
+
+      // Check if already in PATH
+      const currentPath = process.env.PATH || '';
+      if (currentPath.toLowerCase().includes(scriptsDir.toLowerCase())) {
+        logger.info('Python Scripts directory already in PATH');
+        return;
+      }
+
+      // Add to user PATH permanently using PowerShell
+      logger.step('Adding Python Scripts to user PATH...');
+
+      // Escape backslashes for PowerShell
+      const escapedScriptsDir = scriptsDir.replace(/\\/g, '\\\\');
+
+      const psCommand = `$currentPath = [Environment]::GetEnvironmentVariable('Path', 'User'); if ($currentPath -notlike '*${escapedScriptsDir}*') { $newPath = $currentPath + ';${scriptsDir}'; [Environment]::SetEnvironmentVariable('Path', $newPath, 'User'); Write-Host 'PATH updated successfully' } else { Write-Host 'Already in PATH' }`;
+
+      const result = execCommand(`powershell -Command "${psCommand}"`, {
+        silent: true,
+        showCommand: false
+      });
+
+      if (result.success) {
+        logger.success('Python Scripts added to PATH');
+        logger.info('Please restart your terminal for changes to take effect.');
+      } else {
+        logger.warn('Could not automatically add to PATH.');
+        logger.info(`Manually add this to your PATH: ${scriptsDir}`);
+      }
+    } else {
+      // Fallback: try to detect from pip show
+      logger.warn('Could not detect Python scripts directory');
+    }
+    return;
+  }
+
+  logger.step('Configuring Python PATH...');
+
+  const shellConfig = process.env.SHELL?.includes('zsh')
+    ? `${process.env.HOME}/.zshrc`
+    : `${process.env.HOME}/.bashrc`;
+
+  // Add user site-packages to PATH
+  const { python } = getPythonCommands();
+  const userBase = execCommand(`${python} -m site --user-base`, {
+    silent: true,
+    showCommand: false
+  });
+
+  if (userBase.success && userBase.output) {
+    const userBin = `${userBase.output.trim()}/bin`;
+
+    // Check if already in PATH config
+    const checkExisting = execCommand(`grep -q '${userBin}' "${shellConfig}" 2>/dev/null`, {
+      silent: true,
+      showCommand: false
+    });
+
+    if (!checkExisting.success) {
+      // Add to shell config
+      const pathExport = `\n# Python user bin (added by auto-dev-setup)\nexport PATH="${userBin}:$PATH"\n`;
+
+      const fs = require('fs');
+      try {
+        fs.appendFileSync(shellConfig.replace('~', process.env.HOME), pathExport);
+        logger.success(`Added ${userBin} to PATH in ${shellConfig}`);
+      } catch (err) {
+        logger.warn(`Could not update ${shellConfig}: ${err.message}`);
+      }
+    } else {
+      logger.info('Python user bin already in PATH');
+    }
+
+    // Also export for current session
+    process.env.PATH = `${userBin}:${process.env.PATH}`;
+  }
+
+  // Add safe Python aliases (only if not already set)
+  const checkAliases = execCommand(`grep -q "alias py='python3'" "${shellConfig}" 2>/dev/null`, {
+    silent: true,
+    showCommand: false
+  });
+
+  if (!checkAliases.success) {
+    const aliases = `
+# Python aliases (added by auto-dev-setup)
+alias py='python3'
+alias pip='pip3'
+`;
+    const fs = require('fs');
+    try {
+      fs.appendFileSync(shellConfig.replace('~', process.env.HOME), aliases);
+    } catch (err) {
+      // Ignore alias errors
+    }
+  }
+
+  logger.success('Python PATH configured');
+}
+
+/**
+ * Install the Python development stack
+ * @returns {Object} Installation results
+ */
+async function install() {
+  logger.section('Step 4: Python Development Environment');
+
+  const platformModule = getPlatformModule();
+  const results = {
+    installed: [],
+    skipped: [],
+    failed: []
+  };
+
+  // Install Python
+  const pythonResult = await platformModule.installPython();
+  if (pythonResult.success) {
+    (pythonResult.skipped ? results.skipped : results.installed).push('Python');
+  } else {
+    results.failed.push('Python');
+    return results; // Can't continue without Python
+  }
+
+  // Get appropriate commands
+  const { python, pip } = getPythonCommands();
+
+  // Install pipx
+  const pipxResult = await installPipx(pip);
+  if (pipxResult.success) {
+    (pipxResult.skipped ? results.skipped : results.installed).push('pipx');
+  } else {
+    results.failed.push('pipx');
+  }
+
+  // Install virtualenv
+  const venvResult = await installVirtualenv(pip);
+  if (venvResult.success) {
+    (venvResult.skipped ? results.skipped : results.installed).push('virtualenv');
+  } else {
+    results.failed.push('virtualenv');
+  }
+
+  // Install Jupyter
+  const jupyterResult = await installJupyter(pip);
+  if (jupyterResult.success) {
+    (jupyterResult.skipped ? results.skipped : results.installed).push(
+      'Jupyter Notebook'
+    );
+  } else {
+    results.failed.push('Jupyter Notebook');
+  }
+
+  // Install NumPy and Pandas
+  const dataResult = await installDataScienceLibs(pip);
+  if (dataResult.success) {
+    if (dataResult.skipped) {
+      results.skipped.push('NumPy', 'Pandas');
+    } else {
+      results.installed.push('NumPy', 'Pandas');
+    }
+  } else {
+    results.failed.push('NumPy/Pandas');
+  }
+
+  // Configure PATH and aliases
+  await configurePythonPath();
+
+  // Install Python VS Code extensions
+  if (commandExists('code')) {
+    const extResults = await installVSCodeExtensions(VSCODE_EXTENSIONS.python);
+    results.installed.push(...extResults.installed.map((e) => `VS Code: ${e}`));
+    results.skipped.push(...extResults.skipped.map((e) => `VS Code: ${e}`));
+    results.failed.push(...extResults.failed.map((e) => `VS Code: ${e}`));
+  }
+
+  // Verify installations
+  logger.newline();
+  logger.subsection('Python Stack Verification:');
+
+  const verifyPython = execCommand(`${python} --version`, {
+    silent: true,
+    showCommand: true
+  });
+  const verifyPip = execCommand(`${pip} --version`, {
+    silent: true,
+    showCommand: true
+  });
+
+  if (verifyPython.success) {
+    logger.success(`Python: ${verifyPython.output}`);
+  } else {
+    logger.error('Python: not found');
+  }
+
+  if (verifyPip.success) {
+    logger.success(`pip: ${verifyPip.output.split(' ')[0]} ${verifyPip.output.split(' ')[1]}`);
+  } else {
+    logger.error('pip: not found');
+  }
+
+  return results;
+}
+
+/**
+ * Check if Python stack is already installed
+ * @returns {boolean}
+ */
+function isInstalled() {
+  const { python, pip } = getPythonCommands();
+  return commandExists(python) && commandExists(pip);
+}
+
+module.exports = {
+  install,
+  isInstalled,
+  getPythonCommands,
+  installPipx,
+  installVirtualenv,
+  installJupyter,
+  installDataScienceLibs,
+  configurePythonPath
+};

package/src/stacks/web.js

@@ -0,0 +1,208 @@
+/**
+ * Web Developer Stack Installer
+ * Installs Node.js, npm, VS Code, and essential extensions
+ */
+
+const { getPlatformModule } = require('../platform');
+const { execCommand, commandExists } = require('../utils/executor');
+const logger = require('../utils/logger');
+const { verifyWebStack, displayVerification } = require('../utils/verifier');
+const { VSCODE_EXTENSIONS } = require('../config/extensions');
+const ora = require('ora');
+
+/**
+ * Install VS Code extensions
+ * @param {Array} extensions - Array of extension objects
+ * @returns {Object} Installation results
+ */
+async function installVSCodeExtensions(extensions) {
+  const results = {
+    installed: [],
+    skipped: [],
+    failed: []
+  };
+
+  if (!commandExists('code')) {
+    logger.warn('VS Code CLI not available. Cannot install extensions.');
+    return results;
+  }
+
+  logger.step('Installing VS Code extensions...');
+
+  // Get list of installed extensions (cross-platform)
+  const listResult = execCommand('code --list-extensions', {
+    silent: true,
+    showCommand: false
+  });
+
+  const installedExtensions = listResult.success
+    ? listResult.output.toLowerCase().split('\n').map((e) => e.trim())
+    : [];
+
+  for (const ext of extensions) {
+    // Check if already installed (cross-platform check without grep)
+    const isInstalled = installedExtensions.includes(ext.id.toLowerCase());
+
+    if (isInstalled) {
+      logger.listItem(`${ext.name} - already installed`);
+      results.skipped.push(ext.name);
+      continue;
+    }
+
+    logger.listItem(`Installing ${ext.name}...`);
+    const installResult = execCommand(
+      `code --install-extension ${ext.id} --force`,
+      { silent: true, showCommand: false }
+    );
+
+    if (installResult.success) {
+      results.installed.push(ext.name);
+    } else {
+      results.failed.push(ext.name);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Verify npm global install works
+ * @returns {boolean}
+ */
+async function verifyNpmGlobal() {
+  logger.step('Verifying npm global install configuration...');
+
+  // Check npm prefix
+  const prefixResult = execCommand('npm config get prefix', {
+    silent: true,
+    showCommand: false
+  });
+
+  if (prefixResult.success) {
+    logger.info(`npm global prefix: ${prefixResult.output}`);
+  }
+
+  // Try to ensure npm global installs work without sudo
+  const platform = process.platform;
+  if (platform !== 'win32') {
+    const npmDir = prefixResult.output || '~/.npm-global';
+
+    // Check if we need to configure npm prefix
+    if (
+      prefixResult.output?.includes('/usr/local') ||
+      prefixResult.output?.includes('/usr/lib')
+    ) {
+      logger.info('Configuring npm for user-space global installs...');
+
+      execCommand(`mkdir -p ~/.npm-global`, { silent: true, showCommand: false });
+      execCommand(`npm config set prefix '~/.npm-global'`, {
+        silent: true,
+        showCommand: false
+      });
+
+      // Add to PATH
+      const shellConfig = process.env.SHELL?.includes('zsh')
+        ? '~/.zshrc'
+        : '~/.bashrc';
+
+      execCommand(
+        `grep -q 'npm-global' ${shellConfig} || echo 'export PATH=~/.npm-global/bin:$PATH' >> ${shellConfig}`,
+        { silent: true, showCommand: false }
+      );
+
+      logger.success('npm global configuration updated');
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Install the web developer stack
+ * @returns {Object} Installation results
+ */
+async function install() {
+  logger.section('Step 3: Web Developer Stack (Mandatory)');
+
+  const platform = getPlatformModule();
+  const results = {
+    installed: [],
+    skipped: [],
+    failed: []
+  };
+
+  // Install Node.js
+  const nodeResult = await platform.installNode();
+  if (nodeResult.success) {
+    (nodeResult.skipped ? results.skipped : results.installed).push('Node.js');
+  } else {
+    results.failed.push('Node.js');
+  }
+
+  // Verify npm
+  await verifyNpmGlobal();
+
+  // Install VS Code
+  const vscodeResult = await platform.installVSCode();
+  if (vscodeResult.success) {
+    (vscodeResult.skipped ? results.skipped : results.installed).push(
+      'Visual Studio Code'
+    );
+  } else {
+    results.failed.push('Visual Studio Code');
+  }
+
+  // Enable VS Code CLI
+  await platform.enableVSCodeCli();
+
+  // Install essential VS Code extensions
+  const extResults = await installVSCodeExtensions(VSCODE_EXTENSIONS.essential);
+  results.installed.push(...extResults.installed.map((e) => `VS Code: ${e}`));
+  results.skipped.push(...extResults.skipped.map((e) => `VS Code: ${e}`));
+  results.failed.push(...extResults.failed.map((e) => `VS Code: ${e}`));
+
+  // Verify installations
+  logger.newline();
+  logger.subsection('Web Stack Verification:');
+
+  const verifyNode = execCommand('node -v', { silent: true, showCommand: true });
+  const verifyNpm = execCommand('npm -v', { silent: true, showCommand: true });
+  const verifyGit = execCommand('git --version', { silent: true, showCommand: true });
+
+  if (verifyNode.success) {
+    logger.success(`Node.js: ${verifyNode.output}`);
+  } else {
+    logger.error('Node.js: not found');
+  }
+
+  if (verifyNpm.success) {
+    logger.success(`npm: ${verifyNpm.output}`);
+  } else {
+    logger.error('npm: not found');
+  }
+
+  if (verifyGit.success) {
+    logger.success(`Git: ${verifyGit.output}`);
+  } else {
+    logger.error('Git: not found');
+  }
+
+  return results;
+}
+
+/**
+ * Check if web stack is already installed
+ * @returns {boolean}
+ */
+function isInstalled() {
+  return (
+    commandExists('node') && commandExists('npm') && commandExists('git')
+  );
+}
+
+module.exports = {
+  install,
+  isInstalled,
+  installVSCodeExtensions,
+  verifyNpmGlobal
+};