@fredlackey/devutils 0.0.1 → 0.0.2

package/README.md

@@ -60,7 +60,7 @@ dev install node
 dev install vscode
 ```
 
-DevUtils CLI figures out the right command for macOS, Ubuntu, Debian, Amazon Linux, Fedora, or Windows.
+DevUtils CLI figures out the right command for macOS, Ubuntu, Raspberry Pi OS, Amazon Linux, Windows, or Git Bash.
 
 ### Git Identity Management
 
@@ -112,11 +112,11 @@ Copy this file to a new machine and run `dev identity sync` to regenerate all yo
 | Platform | Package Manager |
 |----------|-----------------|
 | macOS | Homebrew |
-| Ubuntu / Debian | APT |
-| Raspberry Pi OS | APT |
-| Amazon Linux / RHEL / Fedora | DNF / YUM |
+| Ubuntu | APT / Snap |
+| Raspberry Pi OS | APT / Snap |
+| Amazon Linux | DNF / YUM |
 | Windows | Chocolatey / winget |
-| WSL | APT (with Windows integration) |
+| Git Bash | Manual / Portable |
 
 ## Available Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fredlackey/devutils",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A globally-installable Node.js CLI toolkit for bootstrapping and configuring development environments across any machine.",
   "main": "src/index.js",
   "bin": {

package/src/commands/install.js

@@ -2,7 +2,17 @@
 
 /**
  * @fileoverview Install command - Platform-agnostic installation of development tools.
- * Locates and executes install scripts from src/installs/.
+ *
+ * This command handles the installation of development tools with automatic
+ * dependency resolution. It performs the following steps for each technology:
+ *
+ * 1. Check if already installed using isInstalled() - skip if true
+ * 2. Check if eligible for current platform using isEligible() - fail if false
+ * 3. Resolve dependencies from installers.json
+ * 4. Recursively check and install dependencies first
+ * 5. Install the requested technology
+ *
+ * @module commands/install
  */
 
 const { Command } = require('commander');
@@ -11,10 +21,87 @@ const path = require('path');
 const readline = require('readline');
 
 const INSTALLS_DIR = path.join(__dirname, '..', 'installs');
+const INSTALLERS_JSON = path.join(INSTALLS_DIR, 'installers.json');
+
+/**
+ * Cache for loaded installer modules to avoid reloading
+ * @type {Map<string, object>}
+ */
+const installerCache = new Map();
+
+/**
+ * Cache for installer metadata from installers.json
+ * @type {Array<object>|null}
+ */
+let installersMetadata = null;
+
+/**
+ * Load the installers.json metadata file
+ * @returns {Array<object>} Array of installer metadata objects
+ */
+function loadInstallersMetadata() {
+  if (installersMetadata !== null) {
+    return installersMetadata;
+  }
+
+  try {
+    if (!fs.existsSync(INSTALLERS_JSON)) {
+      console.warn('Warning: installers.json not found. Dependency resolution disabled.');
+      installersMetadata = [];
+      return installersMetadata;
+    }
+    const content = fs.readFileSync(INSTALLERS_JSON, 'utf8');
+    installersMetadata = JSON.parse(content);
+    return installersMetadata;
+  } catch (err) {
+    console.warn(`Warning: Failed to load installers.json: ${err.message}`);
+    installersMetadata = [];
+    return installersMetadata;
+  }
+}
+
+/**
+ * Get metadata for a specific installer by filename
+ * @param {string} filename - The installer filename (e.g., "node.js")
+ * @returns {object|null} The installer metadata or null if not found
+ */
+function getInstallerMetadata(filename) {
+  const metadata = loadInstallersMetadata();
+  return metadata.find(m => m.filename === filename) || null;
+}
+
+/**
+ * Load an installer module by name
+ * @param {string} name - Name of the installer (without .js extension)
+ * @returns {object|null} The installer module or null if not found
+ */
+function loadInstaller(name) {
+  const filename = `${name}.js`;
+
+  // Check cache first
+  if (installerCache.has(filename)) {
+    return installerCache.get(filename);
+  }
+
+  const scriptPath = path.join(INSTALLS_DIR, filename);
+
+  if (!fs.existsSync(scriptPath)) {
+    return null;
+  }
+
+  try {
+    const installer = require(scriptPath);
+    installerCache.set(filename, installer);
+    return installer;
+  } catch (err) {
+    console.error(`Error loading installer ${name}: ${err.message}`);
+    return null;
+  }
+}
 
 /**
  * Get list of available install scripts
- * @returns {string[]} Array of install script names
+ * @returns {string[]} Array of install script names (without .js extension)
  */
 function getAvailableInstalls() {
   try {
@@ -48,6 +135,194 @@ function confirm(question) {
   });
 }
 
+/**
+ * Check if a technology is installed
+ * @param {string} name - Name of the technology (without .js extension)
+ * @returns {Promise<boolean>} True if installed, false otherwise
+ */
+async function checkIsInstalled(name) {
+  const installer = loadInstaller(name);
+
+  if (!installer) {
+    return false;
+  }
+
+  // Check if installer has isInstalled function
+  if (typeof installer.isInstalled !== 'function') {
+    // If no isInstalled function, assume not installed (will try to install)
+    return false;
+  }
+
+  try {
+    // isInstalled may be sync or async
+    const result = installer.isInstalled();
+    if (result instanceof Promise) {
+      return await result;
+    }
+    return result;
+  } catch (err) {
+    // If check fails, assume not installed
+    return false;
+  }
+}
+
+/**
+ * Check if a technology is eligible for the current platform
+ * @param {string} name - Name of the technology (without .js extension)
+ * @returns {boolean} True if eligible, false otherwise
+ */
+function checkIsEligible(name) {
+  const installer = loadInstaller(name);
+
+  if (!installer) {
+    return false;
+  }
+
+  // Check if installer has isEligible function
+  if (typeof installer.isEligible !== 'function') {
+    // If no isEligible function, assume eligible (backwards compatibility)
+    return true;
+  }
+
+  try {
+    return installer.isEligible();
+  } catch (err) {
+    // If check fails, assume not eligible
+    return false;
+  }
+}
+
+/**
+ * Get the display name for a technology from metadata
+ * @param {string} filename - The installer filename
+ * @returns {string} The display name or the filename without extension
+ */
+function getDisplayName(filename) {
+  const metadata = getInstallerMetadata(filename);
+  if (metadata && metadata.name) {
+    return metadata.name;
+  }
+  return filename.replace('.js', '');
+}
+
+/**
+ * Resolve dependencies for a technology, filtering by eligibility
+ *
+ * This function recursively resolves all dependencies for a given technology,
+ * returning them in the correct installation order (dependencies first).
+ *
+ * @param {string} name - Name of the technology (without .js extension)
+ * @param {Set<string>} visited - Set of already visited technologies (for cycle detection)
+ * @param {Set<string>} installing - Set of technologies currently being resolved (for cycle detection)
+ * @param {object} options - Command options
+ * @returns {Promise<Array<{name: string, displayName: string}>>} Array of technologies to install in order
+ */
+async function resolveDependencies(name, visited = new Set(), installing = new Set(), options = {}) {
+  const filename = `${name}.js`;
+  const result = [];
+
+  // Detect circular dependencies
+  if (installing.has(filename)) {
+    if (options.verbose) {
+      console.log(`  [Skipping circular dependency: ${name}]`);
+    }
+    return result;
+  }
+
+  // Skip if already processed
+  if (visited.has(filename)) {
+    return result;
+  }
+
+  // Mark as being processed
+  installing.add(filename);
+
+  // Get metadata for this installer
+  const metadata = getInstallerMetadata(filename);
+  const dependencies = metadata?.depends_on || [];
+
+  // Sort dependencies by priority (lower priority = install first)
+  const sortedDeps = [...dependencies].sort((a, b) => (a.priority || 0) - (b.priority || 0));
+
+  // Process each dependency
+  for (const dep of sortedDeps) {
+    const depName = dep.name.replace('.js', '');
+
+    // Check if dependency is eligible for this platform
+    if (!checkIsEligible(depName)) {
+      if (options.verbose) {
+        console.log(`  [Skipping ineligible dependency: ${depName}]`);
+      }
+      continue;
+    }
+
+    // Check if dependency is already installed
+    const isInstalled = await checkIsInstalled(depName);
+    if (isInstalled) {
+      if (options.verbose) {
+        console.log(`  [Dependency already installed: ${depName}]`);
+      }
+      visited.add(dep.name);
+      continue;
+    }
+
+    // Recursively resolve this dependency's dependencies
+    const subDeps = await resolveDependencies(depName, visited, installing, options);
+    result.push(...subDeps);
+
+    // Add this dependency if not already visited
+    if (!visited.has(dep.name)) {
+      result.push({
+        name: depName,
+        displayName: getDisplayName(dep.name)
+      });
+      visited.add(dep.name);
+    }
+  }
+
+  // Mark as processed (no longer being resolved)
+  installing.delete(filename);
+
+  return result;
+}
+
+/**
+ * Install a single technology
+ * @param {string} name - Name of the technology to install
+ * @param {object} options - Command options
+ * @returns {Promise<boolean>} True if installation succeeded
+ */
+async function installSingle(name, options) {
+  const installer = loadInstaller(name);
+
+  if (!installer) {
+    console.error(`Error: Installer for "${name}" not found.`);
+    return false;
+  }
+
+  if (typeof installer.install !== 'function') {
+    console.error(`Error: Installer "${name}" does not export an install() function.`);
+    return false;
+  }
+
+  try {
+    const installOptions = {
+      dryRun: options.dryRun || false,
+      verbose: options.verbose || false,
+      force: options.force || false
+    };
+
+    await installer.install(installOptions);
+    return true;
+  } catch (err) {
+    console.error(`Error installing ${name}: ${err.message}`);
+    if (options.verbose) {
+      console.error(err.stack);
+    }
+    return false;
+  }
+}
+
 /**
  * List all available install scripts
  */
@@ -64,7 +339,11 @@ function listInstalls() {
   console.log('─'.repeat(40));
 
   for (const name of installs) {
-    console.log(`  ${name}`);
+    const filename = `${name}.js`;
+    const displayName = getDisplayName(filename);
+    const eligible = checkIsEligible(name);
+    const eligibleMark = eligible ? '' : ' (not available on this platform)';
+    console.log(`  ${name}${eligibleMark}`);
   }
 
   console.log(`\nUsage: dev install <name>`);
@@ -72,7 +351,7 @@ function listInstalls() {
 }
 
 /**
- * Run an install script
+ * Run an install with dependency resolution
  * @param {string} name - Name of the install script
  * @param {object} options - Command options
  */
@@ -85,6 +364,7 @@ async function runInstall(name, options) {
   }
 
   const scriptPath = path.join(INSTALLS_DIR, `${name}.js`);
+  const filename = `${name}.js`;
 
   // Check if install script exists
   if (!fs.existsSync(scriptPath)) {
@@ -93,14 +373,65 @@ async function runInstall(name, options) {
     process.exit(1);
   }
 
-  // Confirm installation (unless --force)
-  if (!options.force) {
-    console.log(`\nPreparing to install: ${name}`);
+  // Get display name for output
+  const displayName = getDisplayName(filename);
+
+  console.log(`\nChecking ${displayName}...`);
+
+  // Step 1: Check if already installed
+  const isInstalled = await checkIsInstalled(name);
+  if (isInstalled) {
+    console.log(`${displayName} is already installed.`);
+    return;
+  }
+
+  // Step 2: Check if eligible for this platform
+  const isEligible = checkIsEligible(name);
+  if (!isEligible) {
+    console.log(`${displayName} is not available for this platform.`);
+    return;
+  }
+
+  // Step 3: Resolve dependencies
+  if (options.verbose) {
+    console.log(`Resolving dependencies for ${displayName}...`);
+  }
+
+  const dependencies = await resolveDependencies(name, new Set(), new Set(), options);
+
+  // Build the full installation list (dependencies + target)
+  const toInstall = [
+    ...dependencies,
+    { name, displayName }
+  ];
 
-    if (options.dryRun) {
-      console.log('[Dry run mode - no changes will be made]\n');
+  // Remove duplicates while preserving order
+  const seen = new Set();
+  const uniqueToInstall = toInstall.filter(item => {
+    if (seen.has(item.name)) {
+      return false;
     }
+    seen.add(item.name);
+    return true;
+  });
+
+  // Show what will be installed
+  if (uniqueToInstall.length > 1) {
+    console.log(`\nThe following will be installed:`);
+    for (const item of uniqueToInstall) {
+      console.log(`  - ${item.displayName}`);
+    }
+    console.log('');
+  } else {
+    console.log(`\nPreparing to install: ${displayName}`);
+  }
 
+  if (options.dryRun) {
+    console.log('[Dry run mode - no changes will be made]\n');
+  }
+
+  // Confirm installation (unless --force)
+  if (!options.force) {
     const shouldProceed = await confirm('Proceed with installation?');
     if (!shouldProceed) {
       console.log('Installation cancelled.');
@@ -108,42 +439,49 @@ async function runInstall(name, options) {
     }
   }
 
-  try {
-    // Load the install script
-    const installScript = require(scriptPath);
+  // Install each technology in order
+  let successCount = 0;
+  let failCount = 0;
 
-    // Check for install function
-    if (typeof installScript.install !== 'function') {
-      console.error(`\nError: Install script "${name}" does not export an install() function.`);
-      process.exit(1);
-    }
+  for (const item of uniqueToInstall) {
+    console.log(`\n${'─'.repeat(50)}`);
+    console.log(`Installing ${item.displayName}...`);
+    console.log('─'.repeat(50));
 
-    console.log(`\nInstalling ${name}...`);
     if (options.verbose) {
-      console.log(`Script: ${scriptPath}`);
+      console.log(`Script: ${path.join(INSTALLS_DIR, `${item.name}.js`)}`);
     }
 
-    // Pass options to the install function
-    const installOptions = {
-      dryRun: options.dryRun || false,
-      verbose: options.verbose || false,
-      force: options.force || false
-    };
+    const success = await installSingle(item.name, options);
 
-    // Run the install
-    await installScript.install(installOptions);
+    if (success) {
+      successCount++;
+      if (!options.dryRun) {
+        console.log(`${item.displayName} installed successfully.`);
+      }
+    } else {
+      failCount++;
+      console.error(`Failed to install ${item.displayName}.`);
 
-    if (!options.dryRun) {
-      console.log(`\n${name} installation complete.`);
+      // Ask if user wants to continue on failure (unless --force)
+      if (!options.force && uniqueToInstall.indexOf(item) < uniqueToInstall.length - 1) {
+        const shouldContinue = await confirm('Continue with remaining installations?');
+        if (!shouldContinue) {
+          console.log('Installation cancelled.');
+          break;
+        }
+      }
     }
+  }
 
-  } catch (err) {
-    console.error(`\nError installing ${name}:`, err.message);
-    if (options.verbose) {
-      console.error(err.stack);
-    }
-    process.exit(1);
+  // Summary
+  console.log(`\n${'─'.repeat(50)}`);
+  console.log('Installation Summary:');
+  console.log(`  Successful: ${successCount}`);
+  if (failCount > 0) {
+    console.log(`  Failed: ${failCount}`);
   }
+  console.log('');
 }
 
 /**
@@ -162,7 +500,7 @@ async function handleInstall(name, options) {
 
 // Create and configure the command
 const install = new Command('install')
-  .description('Platform-agnostic installation of development tools')
+  .description('Platform-agnostic installation of development tools with automatic dependency resolution')
   .argument('[name]', 'Name of the package to install')
   .option('--list', 'List all available install scripts')
   .option('--dry-run', 'Show what would be executed without running')