auto-dev-setup 0.1.0

package/src/utils/executor.js

@@ -0,0 +1,227 @@
+/**
+ * Command Executor Utility
+ * Executes system commands with proper error handling and logging
+ */
+
+const { spawn, execSync } = require('child_process');
+const logger = require('./logger');
+
+/**
+ * Execute a command synchronously
+ * @param {string} command - Command to execute
+ * @param {Object} options - Execution options
+ * @returns {Object} Result with success status and output
+ */
+function execCommand(command, options = {}) {
+  const {
+    silent = false,
+    showCommand = true,
+    throwOnError = false,
+    cwd = process.cwd()
+  } = options;
+
+  if (showCommand && !silent) {
+    logger.command(command);
+  }
+
+  try {
+    const output = execSync(command, {
+      encoding: 'utf8',
+      stdio: silent ? 'pipe' : 'inherit',
+      cwd,
+      shell: true
+    });
+
+    return {
+      success: true,
+      output: output ? output.trim() : '',
+      code: 0
+    };
+  } catch (error) {
+    if (throwOnError) {
+      throw error;
+    }
+
+    return {
+      success: false,
+      output: error.message,
+      code: error.status || 1,
+      error
+    };
+  }
+}
+
+/**
+ * Execute a command and capture output silently
+ * @param {string} command - Command to execute
+ * @returns {Object} Result with output
+ */
+function execSilent(command) {
+  try {
+    const output = execSync(command, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      shell: true
+    });
+    return {
+      success: true,
+      output: output ? output.trim() : ''
+    };
+  } catch (error) {
+    return {
+      success: false,
+      output: error.message,
+      error
+    };
+  }
+}
+
+/**
+ * Execute a command asynchronously with streaming output
+ * @param {string} command - Command to execute
+ * @param {Array} args - Command arguments
+ * @param {Object} options - Execution options
+ * @returns {Promise} Resolves when command completes
+ */
+function execAsync(command, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const { showCommand = true, cwd = process.cwd() } = options;
+
+    const fullCommand = args.length > 0 ? `${command} ${args.join(' ')}` : command;
+
+    if (showCommand) {
+      logger.command(fullCommand);
+    }
+
+    const child = spawn(command, args, {
+      cwd,
+      shell: true,
+      stdio: 'inherit'
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ success: true, code });
+      } else {
+        resolve({ success: false, code });
+      }
+    });
+
+    child.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Check if a command exists
+ * @param {string} command - Command to check
+ * @returns {boolean} True if command exists
+ */
+function commandExists(command) {
+  try {
+    const checkCmd =
+      process.platform === 'win32' ? `where ${command}` : `which ${command}`;
+
+    execSync(checkCmd, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get command version
+ * @param {string} command - Command to check
+ * @param {string} versionFlag - Version flag (default: --version)
+ * @returns {string|null} Version string or null
+ */
+function getVersion(command, versionFlag = '--version') {
+  try {
+    const output = execSync(`${command} ${versionFlag}`, {
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    // Extract version number from output
+    const versionMatch = output.match(/(\d+\.\d+\.?\d*)/);
+    return versionMatch ? versionMatch[1] : output.trim().split('\n')[0];
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Run multiple commands in sequence
+ * @param {Array} commands - Array of command strings
+ * @param {Object} options - Execution options
+ * @returns {Object} Result with success status
+ */
+function execSequence(commands, options = {}) {
+  const results = [];
+
+  for (const cmd of commands) {
+    const result = execCommand(cmd, options);
+    results.push(result);
+
+    if (!result.success && !options.continueOnError) {
+      return {
+        success: false,
+        results,
+        failedAt: cmd
+      };
+    }
+  }
+
+  return {
+    success: results.every((r) => r.success),
+    results
+  };
+}
+
+/**
+ * Execute a command with sudo/admin privileges
+ * @param {string} command - Command to execute
+ * @param {Object} options - Execution options
+ * @returns {Object} Result
+ */
+function execWithPrivileges(command, options = {}) {
+  const platform = process.platform;
+
+  if (platform === 'win32') {
+    // Windows: Command should already be running as admin
+    logger.warn('Windows requires running the terminal as Administrator');
+    return execCommand(command, options);
+  } else {
+    // Unix: Use sudo
+    return execCommand(`sudo ${command}`, options);
+  }
+}
+
+/**
+ * Execute platform-specific command
+ * @param {Object} commands - Object with darwin, linux, win32 keys
+ * @param {Object} options - Execution options
+ * @returns {Object} Result
+ */
+function execPlatformCommand(commands, options = {}) {
+  const platform = process.platform;
+  const command = commands[platform];
+
+  if (!command) {
+    logger.error(`No command defined for platform: ${platform}`);
+    return { success: false, output: 'Platform not supported' };
+  }
+
+  return execCommand(command, options);
+}
+
+module.exports = {
+  execCommand,
+  execSilent,
+  execAsync,
+  commandExists,
+  getVersion,
+  execSequence,
+  execWithPrivileges,
+  execPlatformCommand
+};

package/src/utils/index.js

@@ -0,0 +1,18 @@
+/**
+ * Utilities Index
+ * Central export for all utility modules
+ */
+
+const logger = require('./logger');
+const executor = require('./executor');
+const prompts = require('./prompts');
+const verifier = require('./verifier');
+const postinstall = require('./postinstall');
+
+module.exports = {
+  logger,
+  executor,
+  prompts,
+  verifier,
+  postinstall
+};

package/src/utils/logger.js

@@ -0,0 +1,235 @@
+/**
+ * Logger Utility
+ * Provides consistent, colorful console output
+ */
+
+const chalk = require('chalk');
+const boxen = require('boxen');
+
+const ICONS = {
+  success: '✓',
+  error: '✗',
+  warning: '⚠',
+  info: 'ℹ',
+  arrow: '→',
+  bullet: '•',
+  check: '✔',
+  cross: '✘',
+  star: '★',
+  rocket: '🚀',
+  wrench: '🔧',
+  package: '📦',
+  computer: '💻',
+  folder: '📁'
+};
+
+/**
+ * Log an info message
+ * @param {string} message
+ */
+function info(message) {
+  console.log(chalk.blue(`${ICONS.info} ${message}`));
+}
+
+/**
+ * Log a success message
+ * @param {string} message
+ */
+function success(message) {
+  console.log(chalk.green(`${ICONS.success} ${message}`));
+}
+
+/**
+ * Log an error message
+ * @param {string} message
+ */
+function error(message) {
+  console.log(chalk.red(`${ICONS.error} ${message}`));
+}
+
+/**
+ * Log a warning message
+ * @param {string} message
+ */
+function warn(message) {
+  console.log(chalk.yellow(`${ICONS.warning} ${message}`));
+}
+
+/**
+ * Log a step in a process
+ * @param {string} message
+ */
+function step(message) {
+  console.log(chalk.cyan(`${ICONS.arrow} ${message}`));
+}
+
+/**
+ * Log a command that will be executed
+ * @param {string} command
+ */
+function command(cmd) {
+  console.log(chalk.gray(`  $ ${cmd}`));
+}
+
+/**
+ * Log a section header
+ * @param {string} title
+ */
+function section(title) {
+  console.log('');
+  console.log(chalk.bold.underline(title));
+  console.log('');
+}
+
+/**
+ * Log a subsection
+ * @param {string} title
+ */
+function subsection(title) {
+  console.log('');
+  console.log(chalk.bold(`  ${title}`));
+}
+
+/**
+ * Log a list item
+ * @param {string} message
+ * @param {number} indent
+ */
+function listItem(message, indent = 2) {
+  const spaces = ' '.repeat(indent);
+  console.log(`${spaces}${ICONS.bullet} ${message}`);
+}
+
+/**
+ * Display a banner/box
+ * @param {string} title
+ * @param {string} subtitle
+ */
+function banner(title, subtitle = '') {
+  const content = subtitle ? `${title}\n${chalk.gray(subtitle)}` : title;
+  console.log(
+    boxen(content, {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'cyan'
+    })
+  );
+}
+
+/**
+ * Display platform information
+ * @param {Object} platformInfo
+ */
+function displayPlatformInfo(platformInfo) {
+  console.log('');
+  console.log(
+    boxen(
+      chalk.bold('System Information\n\n') +
+        `${ICONS.computer} OS: ${chalk.cyan(platformInfo.os.name)} (${platformInfo.os.platform})\n` +
+        `${ICONS.wrench} Architecture: ${chalk.cyan(platformInfo.architecture.display)}\n` +
+        `   CPU: ${platformInfo.architecture.cpuModel}\n` +
+        `   Cores: ${platformInfo.architecture.cores}\n` +
+        `${ICONS.folder} Shell: ${chalk.cyan(platformInfo.shell.name)}\n` +
+        `   Config: ${platformInfo.shell.configFile}\n` +
+        `${ICONS.package} Package Manager: ${chalk.cyan(platformInfo.os.packageManager || 'Not detected')}\n` +
+        `   Node.js: ${platformInfo.nodeVersion}\n` +
+        `   User: ${platformInfo.username}@${platformInfo.hostname}`,
+      {
+        padding: 1,
+        borderStyle: 'round',
+        borderColor: 'green'
+      }
+    )
+  );
+  console.log('');
+}
+
+/**
+ * Display installation summary
+ * @param {Array} installed
+ * @param {Array} skipped
+ * @param {Array} failed
+ */
+function displaySummary(installed, skipped, failed) {
+  console.log('');
+  console.log(
+    boxen(
+      chalk.bold('Installation Summary\n\n') +
+        chalk.green.bold(`Installed (${installed.length}):\n`) +
+        (installed.length > 0
+          ? installed.map((item) => `  ${ICONS.check} ${item}`).join('\n')
+          : `  ${chalk.gray('None')}`) +
+        '\n\n' +
+        chalk.yellow.bold(`Skipped (${skipped.length}):\n`) +
+        (skipped.length > 0
+          ? skipped.map((item) => `  ${ICONS.arrow} ${item}`).join('\n')
+          : `  ${chalk.gray('None')}`) +
+        '\n\n' +
+        chalk.red.bold(`Failed (${failed.length}):\n`) +
+        (failed.length > 0
+          ? failed.map((item) => `  ${ICONS.cross} ${item}`).join('\n')
+          : `  ${chalk.gray('None')}`),
+      {
+        padding: 1,
+        borderStyle: 'round',
+        borderColor: failed.length > 0 ? 'red' : 'green'
+      }
+    )
+  );
+  console.log('');
+}
+
+/**
+ * Display success completion message
+ */
+function complete() {
+  console.log('');
+  console.log(
+    boxen(
+      chalk.green.bold(`${ICONS.rocket} Setup Complete!\n\n`) +
+        chalk.white('Your development environment is ready.\n') +
+        chalk.gray('You may need to restart your terminal for all changes to take effect.'),
+      {
+        padding: 1,
+        borderStyle: 'double',
+        borderColor: 'green'
+      }
+    )
+  );
+  console.log('');
+}
+
+/**
+ * Create a newline
+ */
+function newline() {
+  console.log('');
+}
+
+/**
+ * Display a divider
+ */
+function divider() {
+  console.log(chalk.gray('─'.repeat(50)));
+}
+
+module.exports = {
+  info,
+  success,
+  error,
+  warn,
+  step,
+  command,
+  section,
+  subsection,
+  listItem,
+  banner,
+  displayPlatformInfo,
+  displaySummary,
+  complete,
+  newline,
+  divider,
+  ICONS,
+  chalk
+};