auto-dev-setup 0.1.0

package/src/utils/postinstall.js

@@ -0,0 +1,295 @@
+/**
+ * Post-Installation Setup
+ * Ensures all installed tools are properly configured and accessible
+ */
+
+const { execCommand, execSilent, commandExists } = require('./executor');
+const logger = require('./logger');
+
+/**
+ * Get all paths that should be in PATH for the tools to work
+ * @returns {Array} Array of paths to add
+ */
+function getRequiredPaths() {
+  const platform = process.platform;
+  const paths = [];
+
+  if (platform === 'win32') {
+    // Only check Python paths if Python is installed
+    if (commandExists('python') || commandExists('python3')) {
+      // Python user scripts - use sysconfig for correct versioned path
+      const pythonScripts = execSilent(
+        'python -c "import sysconfig; print(sysconfig.get_path(\'scripts\', \'nt_user\'))"'
+      );
+      if (pythonScripts.success && pythonScripts.output) {
+        const scriptsPath = pythonScripts.output.trim();
+        if (scriptsPath && scriptsPath !== 'None') {
+          paths.push({
+            path: scriptsPath,
+            name: 'Python Scripts',
+            tools: ['jupyter', 'pipx', 'virtualenv']
+          });
+        }
+      }
+    }
+
+    // npm global on Windows - only if npm is installed
+    if (commandExists('npm')) {
+      const npmPrefix = execSilent('npm config get prefix');
+      if (npmPrefix.success && npmPrefix.output) {
+        const prefix = npmPrefix.output.trim();
+        // On Windows, npm global binaries are in the prefix folder directly
+        paths.push({
+          path: prefix,
+          name: 'npm global',
+          tools: ['npm global packages']
+        });
+      }
+    }
+
+    // Also check for AppData npm location (common on Windows)
+    const appData = process.env.APPDATA;
+    if (appData) {
+      const npmPath = `${appData}\\npm`;
+      paths.push({
+        path: npmPath,
+        name: 'npm AppData',
+        tools: ['npm global packages']
+      });
+    }
+  } else {
+    // Only check Python paths if Python is installed
+    if (commandExists('python3') || commandExists('python')) {
+      // Unix: Python user bin - use sysconfig for correct path
+      const pythonUserBin = execSilent(
+        'python3 -c "import sysconfig; print(sysconfig.get_path(\'scripts\', scheme=\'posix_user\'))" 2>/dev/null || python -c "import sysconfig; print(sysconfig.get_path(\'scripts\', scheme=\'posix_user\'))"'
+      );
+      if (pythonUserBin.success && pythonUserBin.output) {
+        const binPath = pythonUserBin.output.trim();
+        if (binPath && binPath !== 'None') {
+          paths.push({
+            path: binPath,
+            name: 'Python user bin',
+            tools: ['jupyter', 'pipx', 'virtualenv']
+          });
+        }
+      }
+
+      // Fallback: try site --user-base
+      if (!pythonUserBin.success) {
+        const pythonUserBase = execSilent('python3 -m site --user-base 2>/dev/null || python -m site --user-base');
+        if (pythonUserBase.success && pythonUserBase.output) {
+          paths.push({
+            path: `${pythonUserBase.output.trim()}/bin`,
+            name: 'Python user bin',
+            tools: ['jupyter', 'pipx', 'virtualenv']
+          });
+        }
+      }
+    }
+
+    // npm global (if npm is installed and configured to user space)
+    if (commandExists('npm')) {
+      const npmPrefix = execSilent('npm config get prefix');
+      if (npmPrefix.success && npmPrefix.output) {
+        const prefix = npmPrefix.output.trim();
+        // Only add if it's in user space (not /usr/local or /usr)
+        if (prefix.includes(process.env.HOME) || prefix.includes('.npm-global')) {
+          paths.push({
+            path: `${prefix}/bin`,
+            name: 'npm global',
+            tools: ['npm global packages']
+          });
+        }
+      }
+    }
+
+    // pipx bin directory - always check this on Unix
+    const pipxBin = `${process.env.HOME}/.local/bin`;
+    paths.push({
+      path: pipxBin,
+      name: 'pipx/local bin',
+      tools: ['pipx installed tools']
+    });
+
+    // Homebrew on Apple Silicon
+    if (platform === 'darwin' && process.arch === 'arm64') {
+      paths.push({
+        path: '/opt/homebrew/bin',
+        name: 'Homebrew',
+        tools: ['brew packages']
+      });
+    }
+
+    // Homebrew on Intel Mac
+    if (platform === 'darwin' && process.arch === 'x64') {
+      paths.push({
+        path: '/usr/local/bin',
+        name: 'Homebrew',
+        tools: ['brew packages']
+      });
+    }
+  }
+
+  return paths;
+}
+
+/**
+ * Check which required paths are missing from current PATH
+ * @returns {Array} Missing paths
+ */
+function getMissingPaths() {
+  const requiredPaths = getRequiredPaths();
+  const currentPath = process.env.PATH || '';
+  const missing = [];
+
+  for (const pathInfo of requiredPaths) {
+    if (!currentPath.toLowerCase().includes(pathInfo.path.toLowerCase())) {
+      missing.push(pathInfo);
+    }
+  }
+
+  return missing;
+}
+
+/**
+ * Add missing paths to user's shell configuration (Unix) or environment (Windows)
+ * @returns {Object} Result with paths added
+ */
+async function ensurePathsConfigured() {
+  const platform = process.platform;
+  const requiredPaths = getRequiredPaths();
+  const added = [];
+
+  if (platform === 'win32') {
+    // Windows: Add to user PATH environment variable
+    for (const pathInfo of requiredPaths) {
+      const checkResult = execSilent(
+        `powershell -Command "$p = [Environment]::GetEnvironmentVariable('Path', 'User'); $p -like '*${pathInfo.path.replace(/\\/g, '\\\\')}*'"`
+      );
+
+      if (!checkResult.output?.includes('True')) {
+        const addResult = execCommand(
+          `powershell -Command "$p = [Environment]::GetEnvironmentVariable('Path', 'User'); [Environment]::SetEnvironmentVariable('Path', \\"$p;${pathInfo.path}\\", 'User')"`,
+          { silent: true, showCommand: false }
+        );
+
+        if (addResult.success) {
+          added.push(pathInfo);
+        }
+      }
+    }
+  } else {
+    // Unix: Add to shell config
+    const shellConfig = process.env.SHELL?.includes('zsh')
+      ? `${process.env.HOME}/.zshrc`
+      : `${process.env.HOME}/.bashrc`;
+
+    const fs = require('fs');
+
+    for (const pathInfo of requiredPaths) {
+      // Check if already in config
+      const checkResult = execSilent(`grep -q '${pathInfo.path}' "${shellConfig}" 2>/dev/null`);
+
+      if (!checkResult.success) {
+        try {
+          const exportLine = `\n# ${pathInfo.name} (added by auto-dev-setup)\nexport PATH="${pathInfo.path}:$PATH"\n`;
+          fs.appendFileSync(shellConfig, exportLine);
+          added.push(pathInfo);
+        } catch (err) {
+          // Ignore errors
+        }
+      }
+    }
+  }
+
+  return { added };
+}
+
+/**
+ * Verify all installed tools are accessible
+ * @returns {Object} Verification results
+ */
+function verifyToolsAccessible() {
+  const tools = [
+    { cmd: 'git', name: 'Git', required: true },
+    { cmd: 'node', name: 'Node.js', required: true },
+    { cmd: 'npm', name: 'npm', required: true },
+    { cmd: 'python', name: 'Python', altCmd: 'python3', required: false },
+    { cmd: 'pip', name: 'pip', altCmd: 'pip3', required: false },
+    { cmd: 'pipx', name: 'pipx', required: false },
+    { cmd: 'virtualenv', name: 'virtualenv', required: false },
+    { cmd: 'jupyter', name: 'Jupyter', required: false },
+    { cmd: 'java', name: 'Java', required: false },
+    { cmd: 'code', name: 'VS Code', required: false }
+  ];
+
+  const results = {
+    accessible: [],
+    notAccessible: [],
+    notInstalled: []
+  };
+
+  for (const tool of tools) {
+    if (commandExists(tool.cmd) || (tool.altCmd && commandExists(tool.altCmd))) {
+      results.accessible.push(tool.name);
+    } else {
+      results.notAccessible.push(tool.name);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Display post-installation instructions
+ * @param {Object} options - Display options
+ */
+function displayPostInstallInstructions(options = {}) {
+  const platform = process.platform;
+  const missingPaths = getMissingPaths();
+
+  if (missingPaths.length === 0 && !options.forceShow) {
+    return;
+  }
+
+  logger.newline();
+  logger.warn('Action Required: Restart your terminal');
+  logger.newline();
+
+  if (platform === 'win32') {
+    logger.info('To use all installed tools, please:');
+    logger.listItem('Close this PowerShell/Terminal window completely');
+    logger.listItem('Open a new PowerShell/Terminal window');
+    logger.newline();
+    logger.info('Then verify with:');
+    logger.command('jupyter --version');
+    logger.command('pipx --version');
+    logger.command('java --version');
+  } else if (platform === 'darwin') {
+    logger.info('To use all installed tools, either:');
+    logger.listItem('Restart your terminal, OR');
+    logger.listItem('Run: source ~/.zshrc');
+    logger.newline();
+    logger.info('Then verify with:');
+    logger.command('jupyter --version');
+    logger.command('pipx --version');
+  } else {
+    logger.info('To use all installed tools, either:');
+    logger.listItem('Restart your terminal, OR');
+    const shellConfig = process.env.SHELL?.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+    logger.listItem(`Run: source ${shellConfig}`);
+    logger.newline();
+    logger.info('Then verify with:');
+    logger.command('jupyter --version');
+    logger.command('pipx --version');
+  }
+}
+
+module.exports = {
+  getRequiredPaths,
+  getMissingPaths,
+  ensurePathsConfigured,
+  verifyToolsAccessible,
+  displayPostInstallInstructions
+};

package/src/utils/prompts.js

@@ -0,0 +1,168 @@
+/**
+ * User Prompt Utility
+ * Handles interactive prompts and user input
+ */
+
+const inquirer = require('inquirer');
+const logger = require('./logger');
+
+/**
+ * Ask a yes/no question
+ * @param {string} message - Question to ask
+ * @param {boolean} defaultValue - Default value
+ * @returns {Promise<boolean>} User's answer
+ */
+async function confirm(message, defaultValue = true) {
+  const { answer } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'answer',
+      message,
+      default: defaultValue
+    }
+  ]);
+  return answer;
+}
+
+/**
+ * Ask a multiple choice question
+ * @param {string} message - Question to ask
+ * @param {Array} choices - Array of choices
+ * @returns {Promise<string>} Selected choice
+ */
+async function select(message, choices) {
+  const { answer } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'answer',
+      message,
+      choices
+    }
+  ]);
+  return answer;
+}
+
+/**
+ * Ask for text input
+ * @param {string} message - Question to ask
+ * @param {string} defaultValue - Default value
+ * @returns {Promise<string>} User's input
+ */
+async function input(message, defaultValue = '') {
+  const { answer } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'answer',
+      message,
+      default: defaultValue
+    }
+  ]);
+  return answer;
+}
+
+/**
+ * Ask for multiple selections
+ * @param {string} message - Question to ask
+ * @param {Array} choices - Array of choices
+ * @returns {Promise<Array>} Selected choices
+ */
+async function multiSelect(message, choices) {
+  const { answer } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'answer',
+      message,
+      choices
+    }
+  ]);
+  return answer;
+}
+
+/**
+ * Ask for password input
+ * @param {string} message - Question to ask
+ * @returns {Promise<string>} User's password
+ */
+async function password(message) {
+  const { answer } = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'answer',
+      message,
+      mask: '*'
+    }
+  ]);
+  return answer;
+}
+
+/**
+ * Prompt for Python stack installation
+ * @returns {Promise<boolean>}
+ */
+async function promptPythonStack() {
+  logger.newline();
+  return confirm(
+    'Do you want to install the full Python development environment?',
+    true
+  );
+}
+
+/**
+ * Prompt for Java stack installation
+ * @returns {Promise<boolean>}
+ */
+async function promptJavaStack() {
+  logger.newline();
+  return confirm(
+    'Do you want to install the Java development environment?',
+    true
+  );
+}
+
+/**
+ * Prompt to continue after warning
+ * @param {string} warning - Warning message
+ * @returns {Promise<boolean>}
+ */
+async function continueAfterWarning(warning) {
+  logger.warn(warning);
+  return confirm('Do you want to continue anyway?', false);
+}
+
+/**
+ * Prompt for admin/sudo action
+ * @param {string} action - Action description
+ * @returns {Promise<boolean>}
+ */
+async function promptForElevation(action) {
+  logger.newline();
+  logger.warn(`The following action requires administrator privileges:`);
+  logger.info(action);
+  return confirm('Do you want to proceed?', true);
+}
+
+/**
+ * Press enter to continue
+ */
+async function pressEnterToContinue() {
+  await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'continue',
+      message: 'Press Enter to continue...'
+    }
+  ]);
+}
+
+module.exports = {
+  confirm,
+  select,
+  input,
+  multiSelect,
+  password,
+  promptPythonStack,
+  promptJavaStack,
+  continueAfterWarning,
+  promptForElevation,
+  pressEnterToContinue
+};

package/src/utils/verifier.js

@@ -0,0 +1,204 @@
+/**
+ * Verifier Utility
+ * Verifies installations and checks tool availability
+ */
+
+const { commandExists, getVersion, execSilent } = require('./executor');
+const logger = require('./logger');
+
+/**
+ * Verify a tool is installed
+ * @param {string} command - Command to check
+ * @param {string} name - Display name
+ * @param {string} versionFlag - Version flag
+ * @returns {Object} Verification result
+ */
+function verifyTool(command, name, versionFlag = '--version') {
+  const exists = commandExists(command);
+  const version = exists ? getVersion(command, versionFlag) : null;
+
+  return {
+    name,
+    command,
+    installed: exists,
+    version
+  };
+}
+
+/**
+ * Verify multiple tools
+ * @param {Array} tools - Array of tool objects {command, name, versionFlag}
+ * @returns {Array} Verification results
+ */
+function verifyTools(tools) {
+  return tools.map((tool) =>
+    verifyTool(tool.command, tool.name, tool.versionFlag || '--version')
+  );
+}
+
+/**
+ * Display verification results
+ * @param {Array} results - Verification results
+ */
+function displayVerification(results) {
+  logger.subsection('Verification Results:');
+
+  for (const result of results) {
+    if (result.installed) {
+      logger.success(`${result.name}: ${result.version || 'installed'}`);
+    } else {
+      logger.error(`${result.name}: not installed`);
+    }
+  }
+}
+
+/**
+ * Verify base tools (git, curl/wget)
+ * @returns {Object} Verification results
+ */
+function verifyBaseTools() {
+  const tools = [
+    { command: 'git', name: 'Git' },
+    { command: 'curl', name: 'curl' }
+  ];
+
+  return verifyTools(tools);
+}
+
+/**
+ * Verify web stack (Node, npm, VS Code)
+ * @returns {Object} Verification results
+ */
+function verifyWebStack() {
+  const tools = [
+    { command: 'node', name: 'Node.js', versionFlag: '-v' },
+    { command: 'npm', name: 'npm', versionFlag: '-v' },
+    { command: 'git', name: 'Git' },
+    { command: 'code', name: 'VS Code' }
+  ];
+
+  return verifyTools(tools);
+}
+
+/**
+ * Verify Python stack
+ * @returns {Object} Verification results
+ */
+function verifyPythonStack() {
+  const platform = process.platform;
+  const pythonCmd = platform === 'win32' ? 'python' : 'python3';
+  const pipCmd = platform === 'win32' ? 'pip' : 'pip3';
+
+  const tools = [
+    { command: pythonCmd, name: 'Python' },
+    { command: pipCmd, name: 'pip' },
+    { command: 'pipx', name: 'pipx' },
+    { command: 'virtualenv', name: 'virtualenv' },
+    { command: 'jupyter', name: 'Jupyter' }
+  ];
+
+  return verifyTools(tools);
+}
+
+/**
+ * Verify Java stack
+ * @returns {Object} Verification results
+ */
+function verifyJavaStack() {
+  const tools = [{ command: 'java', name: 'Java' }];
+
+  const results = verifyTools(tools);
+
+  // Check JAVA_HOME
+  const javaHome = process.env.JAVA_HOME;
+  results.push({
+    name: 'JAVA_HOME',
+    command: 'JAVA_HOME',
+    installed: !!javaHome,
+    version: javaHome || 'not set'
+  });
+
+  return results;
+}
+
+/**
+ * Verify VS Code extensions
+ * @param {Array} extensions - Extension IDs to check
+ * @returns {Array} Installed extensions
+ */
+function verifyVSCodeExtensions(extensions) {
+  const result = execSilent('code --list-extensions');
+
+  if (!result.success) {
+    return [];
+  }
+
+  const installedExtensions = result.output.toLowerCase().split('\n');
+
+  return extensions.map((ext) => ({
+    id: ext,
+    installed: installedExtensions.includes(ext.toLowerCase())
+  }));
+}
+
+/**
+ * Check if Homebrew is installed (macOS)
+ * @returns {boolean}
+ */
+function isHomebrewInstalled() {
+  return commandExists('brew');
+}
+
+/**
+ * Check if Xcode CLI tools are installed (macOS)
+ * @returns {boolean}
+ */
+function isXcodeCliInstalled() {
+  const result = execSilent('xcode-select -p');
+  return result.success;
+}
+
+/**
+ * Check if winget is available (Windows)
+ * @returns {boolean}
+ */
+function isWingetAvailable() {
+  return commandExists('winget');
+}
+
+/**
+ * Check if chocolatey is available (Windows)
+ * @returns {boolean}
+ */
+function isChocolateyAvailable() {
+  return commandExists('choco');
+}
+
+/**
+ * Run all verifications and return summary
+ * @returns {Object} Complete verification summary
+ */
+function runAllVerifications() {
+  return {
+    base: verifyBaseTools(),
+    web: verifyWebStack(),
+    python: verifyPythonStack(),
+    java: verifyJavaStack()
+  };
+}
+
+module.exports = {
+  verifyTool,
+  verifyTools,
+  displayVerification,
+  verifyBaseTools,
+  verifyWebStack,
+  verifyPythonStack,
+  verifyJavaStack,
+  verifyVSCodeExtensions,
+  isHomebrewInstalled,
+  isXcodeCliInstalled,
+  isWingetAvailable,
+  isChocolateyAvailable,
+  runAllVerifications
+};