@fredlackey/devutils 0.0.18 → 0.0.19

package/src/scripts/y.js

@@ -1,283 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * y - Shortcut for yarn commands
- *
- * Migrated from legacy dotfiles alias.
- * Original: alias y="yarn"
- *
- * This script provides a single-character shortcut for the Yarn package manager,
- * passing all arguments through to the `yarn` command. Yarn is a popular
- * JavaScript package manager that is an alternative to npm.
- *
- * Examples:
- *   y                  -> yarn (runs default yarn command, typically install)
- *   y add lodash       -> yarn add lodash
- *   y remove lodash    -> yarn remove lodash
- *   y dev              -> yarn dev (runs the "dev" script)
- *   y build            -> yarn build (runs the "build" script)
- *   y --version        -> yarn --version
- *
- * @module scripts/y
- */
-
-const os = require('../utils/common/os');
-const { spawn } = require('child_process');
-const { commandExists } = require('../utils/common/shell');
-
-/**
- * Pure Node.js implementation that works on any platform.
- *
- * This function spawns the `yarn` command with all provided arguments.
- * It uses spawn with stdio: 'inherit' to:
- * 1. Pass through all arguments exactly as provided
- * 2. Preserve colored output from yarn
- * 3. Allow interactive prompts if yarn needs user input
- * 4. Properly forward stdin, stdout, and stderr
- *
- * The exit code from yarn is preserved and passed to the parent process,
- * ensuring that CI/CD pipelines and scripts can detect yarn failures.
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y_nodejs(args) {
-  // First, check if yarn is installed
-  if (!commandExists('yarn')) {
-    console.error('Error: yarn is not installed or not in PATH.');
-    console.error('');
-    console.error('To install yarn, you can use one of the following methods:');
-    console.error('');
-    console.error('  Using npm (recommended if you have Node.js):');
-    console.error('    npm install -g yarn');
-    console.error('');
-    console.error('  Using Corepack (Node.js 16.10+):');
-    console.error('    corepack enable');
-    console.error('');
-    console.error('  Using Homebrew (macOS):');
-    console.error('    brew install yarn');
-    console.error('');
-    console.error('  Using apt (Ubuntu/Debian):');
-    console.error('    sudo apt install yarn');
-    console.error('');
-    console.error('For more information, visit: https://yarnpkg.com/getting-started/install');
-    process.exit(1);
-  }
-
-  // Spawn yarn with all arguments, inheriting stdio for full interactivity
-  // This preserves:
-  // - Colored output (yarn uses colors extensively)
-  // - Interactive prompts (e.g., yarn init questions)
-  // - Progress indicators and spinners
-  // - Proper terminal width detection
-  return new Promise((resolve, reject) => {
-    const child = spawn('yarn', args, {
-      stdio: 'inherit',  // Pass through stdin, stdout, stderr
-      shell: false       // Run yarn directly, not through a shell (more efficient)
-    });
-
-    child.on('close', (code) => {
-      // Preserve yarn's exit code so CI/CD can detect failures
-      // Exit code 0 = success, non-zero = failure
-      if (code !== 0) {
-        process.exit(code);
-      }
-      resolve();
-    });
-
-    child.on('error', (err) => {
-      // This typically happens if yarn is not found (though we check above)
-      // or if there's a permission issue
-      console.error(`Error executing yarn: ${err.message}`);
-      process.exit(1);
-    });
-  });
-}
-
-/**
- * Execute yarn on macOS.
- *
- * Uses the pure Node.js implementation since yarn behaves identically
- * on all platforms - it's a cross-platform tool by design.
- *
- * On macOS, yarn is typically installed via:
- * - npm install -g yarn
- * - brew install yarn
- * - Corepack (corepack enable)
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y_macos(args) {
-  return do_y_nodejs(args);
-}
-
-/**
- * Execute yarn on Ubuntu.
- *
- * Uses the pure Node.js implementation since yarn behaves identically
- * on all platforms - it's a cross-platform tool by design.
- *
- * On Ubuntu, yarn is typically installed via:
- * - npm install -g yarn
- * - sudo apt install yarn (from official yarn repository)
- * - Corepack (corepack enable)
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y_ubuntu(args) {
-  return do_y_nodejs(args);
-}
-
-/**
- * Execute yarn on Raspberry Pi OS.
- *
- * Uses the pure Node.js implementation since yarn behaves identically
- * on all platforms - it's a cross-platform tool by design.
- *
- * On Raspberry Pi OS, yarn is typically installed via:
- * - npm install -g yarn
- * - Corepack (corepack enable)
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y_raspbian(args) {
-  return do_y_nodejs(args);
-}
-
-/**
- * Execute yarn on Amazon Linux.
- *
- * Uses the pure Node.js implementation since yarn behaves identically
- * on all platforms - it's a cross-platform tool by design.
- *
- * On Amazon Linux, yarn is typically installed via:
- * - npm install -g yarn
- * - Corepack (corepack enable)
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y_amazon_linux(args) {
-  return do_y_nodejs(args);
-}
-
-/**
- * Execute yarn in Windows Command Prompt.
- *
- * Uses the pure Node.js implementation since yarn behaves identically
- * on all platforms - it's a cross-platform tool by design.
- *
- * On Windows, yarn is typically installed via:
- * - npm install -g yarn
- * - choco install yarn (Chocolatey)
- * - winget install Yarn.Yarn
- * - Corepack (corepack enable)
- *
- * Note: On Windows, yarn is typically installed as yarn.cmd or yarn.ps1,
- * but spawn will find it correctly through the PATH.
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y_cmd(args) {
-  return do_y_nodejs(args);
-}
-
-/**
- * Execute yarn in Windows PowerShell.
- *
- * Uses the pure Node.js implementation since yarn behaves identically
- * on all platforms - it's a cross-platform tool by design.
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y_powershell(args) {
-  return do_y_nodejs(args);
-}
-
-/**
- * Execute yarn in Git Bash on Windows.
- *
- * Uses the pure Node.js implementation since yarn behaves identically
- * on all platforms - it's a cross-platform tool by design.
- *
- * Git Bash can access Windows-installed yarn through the PATH.
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y_gitbash(args) {
-  return do_y_nodejs(args);
-}
-
-/**
- * Main entry point - detects environment and executes appropriate implementation.
- *
- * The "y" command is a shortcut for yarn, the JavaScript package manager.
- * All arguments are passed through to yarn unchanged.
- *
- * This script is idempotent by nature - running yarn commands multiple times
- * will produce consistent results (yarn itself handles idempotency for
- * operations like install).
- *
- * Common usage patterns:
- *   y                  - Install dependencies (equivalent to yarn install)
- *   y add <package>    - Add a new dependency
- *   y remove <package> - Remove a dependency
- *   y <script>         - Run a script from package.json
- *   y upgrade          - Upgrade dependencies
- *   y --help           - Show yarn help
- *
- * @param {string[]} args - Command line arguments to pass to yarn
- * @returns {Promise<void>}
- */
-async function do_y(args) {
-  const platform = os.detect();
-
-  const handlers = {
-    'macos': do_y_macos,
-    'ubuntu': do_y_ubuntu,
-    'debian': do_y_ubuntu,
-    'raspbian': do_y_raspbian,
-    'amazon_linux': do_y_amazon_linux,
-    'rhel': do_y_amazon_linux,
-    'fedora': do_y_ubuntu,
-    'linux': do_y_ubuntu,
-    'wsl': do_y_ubuntu,
-    'cmd': do_y_cmd,
-    'windows': do_y_cmd,
-    'powershell': do_y_powershell,
-    'gitbash': do_y_gitbash
-  };
-
-  const handler = handlers[platform.type];
-  if (!handler) {
-    // Yarn is cross-platform, so try the Node.js implementation anyway
-    console.error(`Note: Platform '${platform.type}' not explicitly supported, attempting to run yarn...`);
-    await do_y_nodejs(args);
-    return;
-  }
-
-  await handler(args);
-}
-
-module.exports = {
-  main: do_y,
-  do_y,
-  do_y_nodejs,
-  do_y_macos,
-  do_y_ubuntu,
-  do_y_raspbian,
-  do_y_amazon_linux,
-  do_y_cmd,
-  do_y_powershell,
-  do_y_gitbash
-};
-
-if (require.main === module) {
-  do_y(process.argv.slice(2));
-}

package/src/utils/README.md

@@ -1,95 +0,0 @@
-# Utils
-
-This folder contains internal shared utilities used by Commands, Scripts, and Installs.
-
-## Purpose
-
-Utils provide common functionality that is reused across the package. These are **not** directly invokable by users — they are internal helpers.
-
-## Planned Utilities
-
-| File | Description |
-|------|-------------|
-| `os.js` | Operating system detection (macOS, Debian, RHEL, Windows, WSL) |
-| `shell.js` | Shell command execution wrappers |
-| `config.js` | Read/write `~/.devutils` configuration file |
-| `prompts.js` | Interactive user prompts and wizards |
-| `logger.js` | Consistent logging and output formatting |
-| `paths.js` | Path resolution and home directory helpers |
-| `git.js` | Git repository detection and operations |
-| `npm.js` | npm/package.json utilities |
-
-## Example: OS Detection
-
-```javascript
-// utils/os.js
-
-function detect() {
-  const platform = process.platform;
-
-  if (platform === 'darwin') {
-    return { type: 'macos', packageManager: 'brew' };
-  }
-
-  if (platform === 'linux') {
-    // Check for WSL
-    if (process.env.WSL_DISTRO_NAME) {
-      return { type: 'windows-wsl', packageManager: 'apt' };
-    }
-    // Check for Debian-based (apt)
-    if (fs.existsSync('/etc/debian_version')) {
-      return { type: 'debian', packageManager: 'apt' };
-    }
-    // Check for RHEL-based (yum/dnf)
-    if (fs.existsSync('/etc/redhat-release')) {
-      return { type: 'rhel', packageManager: 'dnf' };
-    }
-  }
-
-  if (platform === 'win32') {
-    return { type: 'windows', packageManager: 'choco' };
-  }
-
-  return { type: 'unknown', packageManager: null };
-}
-
-module.exports = { detect };
-```
-
-## Example: Config Helper
-
-```javascript
-// utils/config.js
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const CONFIG_PATH = path.join(os.homedir(), '.devutils');
-
-function read() {
-  if (!fs.existsSync(CONFIG_PATH)) {
-    return null;
-  }
-  return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-}
-
-function write(config) {
-  config.updated = new Date().toISOString();
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-}
-
-module.exports = { read, write, CONFIG_PATH };
-```
-
-## Guidelines
-
-1. **Single responsibility** — Each util should do one thing well
-2. **No side effects** — Avoid global state; return values instead
-3. **Error handling** — Throw descriptive errors; let callers handle them
-4. **Platform-aware** — Consider cross-platform compatibility
-
-## Related
-
-- **Commands** (`../commands/`) — Use utils for common operations
-- **Scripts** (`../scripts/`) — Use utils for OS detection, shell execution
-- **Installs** (`../installs/`) — Use `os.js` for platform detection

package/src/utils/common/apps.js

@@ -1,143 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Generic Application Detection Utilities
- *
- * Cross-platform utilities for detecting installed applications.
- * Delegates to OS-specific implementations for actual detection.
- */
-
-const osUtils = require('./os');
-const shell = require('./shell');
-
-/**
- * Cross-platform check if an application is installed
- * Delegates to OS-specific implementations
- * @param {string} appName - The application name to check
- * @returns {Promise<boolean>}
- */
-async function isInstalled(appName) {
-  const platform = osUtils.detect();
-
-  switch (platform.type) {
-    case 'macos': {
-      const macosApps = require('../macos/apps');
-      return macosApps.isAppInstalled(appName);
-    }
-    case 'ubuntu':
-    case 'debian':
-    case 'raspbian': {
-      const apt = require('../ubuntu/apt');
-      const snap = require('../ubuntu/snap');
-      // Check both apt and snap
-      const aptInstalled = await apt.isPackageInstalled(appName);
-      if (aptInstalled) return true;
-      const snapInstalled = await snap.isSnapInstalled(appName);
-      return snapInstalled;
-    }
-    case 'windows': {
-      const registry = require('../windows/registry');
-      return registry.isAppInstalled(appName);
-    }
-    default:
-      // Fallback: check if command exists in PATH
-      return shell.commandExists(appName);
-  }
-}
-
-/**
- * Retrieves the installed version of an application
- * @param {string} appName - The application name
- * @returns {Promise<string|null>}
- */
-async function getVersion(appName) {
-  const platform = osUtils.detect();
-
-  switch (platform.type) {
-    case 'macos': {
-      const macosApps = require('../macos/apps');
-      return macosApps.getAppVersion(appName);
-    }
-    case 'ubuntu':
-    case 'debian':
-    case 'raspbian': {
-      const apt = require('../ubuntu/apt');
-      const snap = require('../ubuntu/snap');
-      // Check apt first
-      const aptVersion = await apt.getPackageVersion(appName);
-      if (aptVersion) return aptVersion;
-      // Then snap
-      const snapVersion = await snap.getSnapVersion(appName);
-      return snapVersion;
-    }
-    case 'windows': {
-      const registry = require('../windows/registry');
-      return registry.getAppVersion(appName);
-    }
-    default:
-      // Fallback: try running appName --version
-      return getVersionFromCommand(appName);
-  }
-}
-
-/**
- * Returns the installation path of an application
- * @param {string} appName - The application name
- * @returns {Promise<string|null>}
- */
-async function getInstallPath(appName) {
-  const platform = osUtils.detect();
-
-  switch (platform.type) {
-    case 'macos': {
-      const macosApps = require('../macos/apps');
-      return macosApps.getAppBundlePath(appName);
-    }
-    case 'windows': {
-      const registry = require('../windows/registry');
-      return registry.getInstallPath(appName);
-    }
-    default:
-      // Fallback: try to find the executable
-      return shell.which(appName);
-  }
-}
-
-/**
- * Tries to get version by running the command with --version flag
- * @param {string} command - The command to check
- * @returns {Promise<string|null>}
- */
-async function getVersionFromCommand(command) {
-  const versionFlags = ['--version', '-v', '-V', 'version'];
-
-  for (const flag of versionFlags) {
-    const result = await shell.exec(`${command} ${flag}`);
-    if (result.code === 0 && result.stdout) {
-      // Try to extract version number from output
-      const versionMatch = result.stdout.match(/(\d+\.\d+\.?\d*)/);
-      if (versionMatch) {
-        return versionMatch[1];
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * Checks if a command-line tool is available
- * @param {string} command - The command to check
- * @returns {boolean}
- */
-function isCommandAvailable(command) {
-  return shell.commandExists(command);
-}
-
-module.exports = {
-  isInstalled,
-  getVersion,
-  getInstallPath,
-  getVersionFromCommand,
-  isCommandAvailable
-};

package/src/utils/common/display.js

@@ -1,157 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Display and GUI Detection Utilities
- *
- * Platform-agnostic utilities for detecting display server availability.
- * Used to determine if GUI applications can be installed/run.
- */
-
-const fs = require('fs');
-
-/**
- * Checks if a display server is available
- * On macOS: Always true (Aqua/Quartz is always present)
- * On Windows: Always true (Windows Desktop is always present)
- * On Linux: Checks for X11 or Wayland display
- * @returns {boolean}
- */
-function hasDisplay() {
-  const platform = process.platform;
-
-  // macOS always has a display (Aqua/Quartz)
-  if (platform === 'darwin') {
-    return true;
-  }
-
-  // Windows always has a display (unless running as a service, which is rare)
-  if (platform === 'win32') {
-    return true;
-  }
-
-  // Linux: check for X11 or Wayland
-  if (platform === 'linux') {
-    return hasX11Display() || hasWaylandDisplay();
-  }
-
-  return false;
-}
-
-/**
- * Checks if running in a headless environment (no GUI)
- * @returns {boolean}
- */
-function isHeadless() {
-  return !hasDisplay();
-}
-
-/**
- * Checks if X11 display is available
- * @returns {boolean}
- */
-function hasX11Display() {
-  // Check DISPLAY environment variable
-  if (process.env.DISPLAY) {
-    return true;
-  }
-
-  // Check if X server socket exists
-  const x11SocketPath = '/tmp/.X11-unix';
-  if (fs.existsSync(x11SocketPath)) {
-    try {
-      const sockets = fs.readdirSync(x11SocketPath);
-      return sockets.length > 0;
-    } catch {
-      return false;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Checks if Wayland display is available
- * @returns {boolean}
- */
-function hasWaylandDisplay() {
-  // Check WAYLAND_DISPLAY environment variable
-  if (process.env.WAYLAND_DISPLAY) {
-    return true;
-  }
-
-  // Check if Wayland socket exists in XDG_RUNTIME_DIR
-  const runtimeDir = process.env.XDG_RUNTIME_DIR;
-  if (runtimeDir) {
-    const waylandSocketPath = `${runtimeDir}/wayland-0`;
-    if (fs.existsSync(waylandSocketPath)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Gets the type of display server in use
- * @returns {'aqua'|'windows'|'x11'|'wayland'|null}
- */
-function getDisplayType() {
-  const platform = process.platform;
-
-  if (platform === 'darwin') {
-    return 'aqua';
-  }
-
-  if (platform === 'win32') {
-    return 'windows';
-  }
-
-  if (platform === 'linux') {
-    if (hasWaylandDisplay()) {
-      return 'wayland';
-    }
-    if (hasX11Display()) {
-      return 'x11';
-    }
-  }
-
-  return null;
-}
-
-/**
- * Gets the display variable value (DISPLAY or WAYLAND_DISPLAY)
- * @returns {string|null}
- */
-function getDisplayVariable() {
-  if (process.env.WAYLAND_DISPLAY) {
-    return process.env.WAYLAND_DISPLAY;
-  }
-  if (process.env.DISPLAY) {
-    return process.env.DISPLAY;
-  }
-  return null;
-}
-
-/**
- * Checks if SSH session has X11 forwarding enabled
- * @returns {boolean}
- */
-function hasX11Forwarding() {
-  // Check if we're in an SSH session with DISPLAY set
-  if (process.env.SSH_CONNECTION && process.env.DISPLAY) {
-    // DISPLAY typically looks like "localhost:10.0" for X11 forwarding
-    const display = process.env.DISPLAY;
-    return display.includes(':');
-  }
-  return false;
-}
-
-module.exports = {
-  hasDisplay,
-  isHeadless,
-  hasX11Display,
-  hasWaylandDisplay,
-  getDisplayType,
-  getDisplayVariable,
-  hasX11Forwarding
-};