@fredlackey/devutils 0.0.17 → 0.0.19

package/src/scripts/count-folders.js

@@ -1,211 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * count-folders - Count only directories (not files) in the current or specified directory
- *
- * Migrated from legacy dotfiles alias.
- * Original: alias count-folders="find . -mindepth 1 -maxdepth 1 -type d | wc -l"
- *
- * This script counts only directories in a directory, excluding regular files.
- * It reads the directory contents and filters for directories only, then prints the count.
- * Unlike the original shell alias, this uses pure Node.js for cross-platform support.
- *
- * @module scripts/count-folders
- */
-
-const os = require('../utils/common/os');
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Pure Node.js implementation that works on any platform.
- * Counts the number of directories (not files) in the specified directory.
- *
- * This approach uses fs.readdirSync with the { withFileTypes: true } option,
- * which returns Dirent objects that include file type information. This is
- * more efficient than calling stat() on each entry individually.
- *
- * @param {string[]} args - Command line arguments
- * @param {string} [args[0]] - Optional path to count (defaults to current directory)
- * @returns {Promise<void>}
- */
-async function do_count_folders_nodejs(args) {
-  // Get the target directory from arguments, defaulting to current directory
-  const targetDir = args[0] || '.';
-
-  // Resolve to absolute path for clearer error messages
-  const absolutePath = path.resolve(targetDir);
-
-  // Check if the path exists
-  if (!fs.existsSync(absolutePath)) {
-    console.error(`Error: Directory not found: ${absolutePath}`);
-    process.exit(1);
-  }
-
-  // Check if the path is a directory
-  const stats = fs.statSync(absolutePath);
-  if (!stats.isDirectory()) {
-    console.error(`Error: Not a directory: ${absolutePath}`);
-    process.exit(1);
-  }
-
-  try {
-    // Read directory contents with file type information included
-    // The { withFileTypes: true } option returns Dirent objects instead of strings
-    const entries = fs.readdirSync(absolutePath, { withFileTypes: true });
-
-    // Filter for directories only (not files, symlinks to files, etc.)
-    // dirent.isDirectory() returns true only for directories
-    const folders = entries.filter(dirent => dirent.isDirectory());
-
-    // Print the count (matching original alias output: just the number)
-    console.log(folders.length);
-  } catch (error) {
-    // Handle permission errors or other filesystem issues
-    console.error(`Error reading directory: ${error.message}`);
-    process.exit(1);
-  }
-}
-
-/**
- * Count folders on macOS.
- * Uses the pure Node.js implementation since folder counting works identically
- * across all platforms using the fs module.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_folders_macos(args) {
-  return do_count_folders_nodejs(args);
-}
-
-/**
- * Count folders on Ubuntu.
- * Uses the pure Node.js implementation since folder counting works identically
- * across all platforms using the fs module.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_folders_ubuntu(args) {
-  return do_count_folders_nodejs(args);
-}
-
-/**
- * Count folders on Raspberry Pi OS.
- * Uses the pure Node.js implementation since folder counting works identically
- * across all platforms using the fs module.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_folders_raspbian(args) {
-  return do_count_folders_nodejs(args);
-}
-
-/**
- * Count folders on Amazon Linux.
- * Uses the pure Node.js implementation since folder counting works identically
- * across all platforms using the fs module.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_folders_amazon_linux(args) {
-  return do_count_folders_nodejs(args);
-}
-
-/**
- * Count folders in Windows Command Prompt.
- * Uses the pure Node.js implementation since folder counting works identically
- * across all platforms using the fs module.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_folders_cmd(args) {
-  return do_count_folders_nodejs(args);
-}
-
-/**
- * Count folders in Windows PowerShell.
- * Uses the pure Node.js implementation since folder counting works identically
- * across all platforms using the fs module.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_folders_powershell(args) {
-  return do_count_folders_nodejs(args);
-}
-
-/**
- * Count folders in Git Bash on Windows.
- * Uses the pure Node.js implementation since folder counting works identically
- * across all platforms using the fs module.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_folders_gitbash(args) {
-  return do_count_folders_nodejs(args);
-}
-
-/**
- * Main entry point - detects environment and executes appropriate implementation.
- *
- * Counts the number of directories (not files) in the current or specified
- * directory. This is useful for quickly checking how many subdirectories exist
- * in a folder without counting regular files.
- *
- * Usage:
- *   count-folders           # Count folders in current directory
- *   count-folders /path     # Count folders in specified directory
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_folders(args) {
-  const platform = os.detect();
-
-  const handlers = {
-    'macos': do_count_folders_macos,
-    'ubuntu': do_count_folders_ubuntu,
-    'debian': do_count_folders_ubuntu,
-    'raspbian': do_count_folders_raspbian,
-    'amazon_linux': do_count_folders_amazon_linux,
-    'rhel': do_count_folders_amazon_linux,
-    'fedora': do_count_folders_ubuntu,
-    'linux': do_count_folders_ubuntu,
-    'wsl': do_count_folders_ubuntu,
-    'cmd': do_count_folders_cmd,
-    'windows': do_count_folders_cmd,
-    'powershell': do_count_folders_powershell,
-    'gitbash': do_count_folders_gitbash
-  };
-
-  const handler = handlers[platform.type];
-  if (!handler) {
-    console.error(`Platform '${platform.type}' is not supported for this command.`);
-    process.exit(1);
-  }
-
-  await handler(args);
-}
-
-module.exports = {
-  main: do_count_folders,
-  do_count_folders,
-  do_count_folders_nodejs,
-  do_count_folders_macos,
-  do_count_folders_ubuntu,
-  do_count_folders_raspbian,
-  do_count_folders_amazon_linux,
-  do_count_folders_cmd,
-  do_count_folders_powershell,
-  do_count_folders_gitbash
-};
-
-if (require.main === module) {
-  do_count_folders(process.argv.slice(2));
-}

package/src/scripts/count.js

@@ -1,264 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * count - Count files and folders in current directory
- *
- * Migrated from legacy dotfiles alias.
- * Original: alias count='echo "Files  : $(find . -maxdepth 1 -type f | wc -l)" && echo "Folders: $(find . -mindepth 1 -maxdepth 1 -type d | wc -l)"'
- *
- * This script counts the number of files and folders in the current (or specified)
- * directory. It only counts items at the top level (non-recursive) and displays
- * separate counts for files and directories.
- *
- * Usage:
- *   count              # Count in current directory
- *   count /some/path   # Count in specified directory
- *
- * @module scripts/count
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('../utils/common/os');
-
-/**
- * Pure Node.js implementation that works on any platform.
- *
- * This function reads the directory entries and counts files and folders separately.
- * It uses the Node.js fs module which works identically on all platforms, so all
- * platform-specific functions simply delegate to this implementation.
- *
- * Why Node.js instead of shell commands?
- * - The original alias used `find` and `wc` which are Unix-specific
- * - Node.js fs.readdirSync with withFileTypes works on macOS, Linux, AND Windows
- * - No external dependencies needed - pure Node.js
- * - Consistent behavior across all platforms
- *
- * @param {string[]} args - Command line arguments
- * @param {string} [args[0]] - Optional path to count (defaults to current directory)
- * @returns {Promise<void>}
- */
-async function do_count_nodejs(args) {
-  // Determine which directory to count
-  // If the user provides a path, use it; otherwise use current working directory
-  const targetDir = args[0] || process.cwd();
-
-  // Resolve to absolute path for clarity in error messages
-  const absolutePath = path.resolve(targetDir);
-
-  // Check if the path exists and is a directory
-  if (!fs.existsSync(absolutePath)) {
-    console.error(`Error: Path does not exist: ${absolutePath}`);
-    process.exit(1);
-  }
-
-  // Get stats to verify it's a directory
-  let stats;
-  try {
-    stats = fs.statSync(absolutePath);
-  } catch (error) {
-    console.error(`Error: Cannot access path: ${absolutePath}`);
-    console.error(error.message);
-    process.exit(1);
-  }
-
-  if (!stats.isDirectory()) {
-    console.error(`Error: Path is not a directory: ${absolutePath}`);
-    process.exit(1);
-  }
-
-  // Read directory contents with file type information
-  // withFileTypes: true returns Dirent objects which include isFile() and isDirectory() methods
-  let entries;
-  try {
-    entries = fs.readdirSync(absolutePath, { withFileTypes: true });
-  } catch (error) {
-    console.error(`Error: Cannot read directory: ${absolutePath}`);
-    console.error(error.message);
-    process.exit(1);
-  }
-
-  // Count files and folders separately
-  // We iterate once through all entries and categorize each one
-  let fileCount = 0;
-  let folderCount = 0;
-
-  for (const entry of entries) {
-    if (entry.isFile()) {
-      // Regular files (not directories, not symlinks to directories)
-      fileCount++;
-    } else if (entry.isDirectory()) {
-      // Directories (folders)
-      folderCount++;
-    }
-    // Note: symlinks, block devices, character devices, etc. are not counted
-    // This matches the original alias behavior which only counted -type f and -type d
-  }
-
-  // Display results in the same format as the original alias
-  // The original output was:
-  //   Files  : 42
-  //   Folders: 7
-  console.log(`Files  : ${fileCount}`);
-  console.log(`Folders: ${folderCount}`);
-}
-
-/**
- * Count files and folders on macOS.
- *
- * macOS supports the Node.js fs module fully, so we delegate to the pure
- * Node.js implementation. This provides the same result as the original
- * bash alias but without requiring find or wc commands.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_macos(args) {
-  return do_count_nodejs(args);
-}
-
-/**
- * Count files and folders on Ubuntu.
- *
- * Ubuntu supports the Node.js fs module fully, so we delegate to the pure
- * Node.js implementation. This provides consistent behavior whether on
- * desktop or server Ubuntu.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_ubuntu(args) {
-  return do_count_nodejs(args);
-}
-
-/**
- * Count files and folders on Raspberry Pi OS.
- *
- * Raspberry Pi OS (Raspbian) is Debian-based and supports the Node.js fs
- * module fully. We delegate to the pure Node.js implementation.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_raspbian(args) {
-  return do_count_nodejs(args);
-}
-
-/**
- * Count files and folders on Amazon Linux.
- *
- * Amazon Linux supports the Node.js fs module fully, so we delegate to the
- * pure Node.js implementation. This works on both Amazon Linux 2 and 2023.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_amazon_linux(args) {
-  return do_count_nodejs(args);
-}
-
-/**
- * Count files and folders in Windows Command Prompt.
- *
- * Windows supports the Node.js fs module fully, so we delegate to the pure
- * Node.js implementation. This avoids the complexity of using dir commands
- * or PowerShell from CMD.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_cmd(args) {
-  return do_count_nodejs(args);
-}
-
-/**
- * Count files and folders in Windows PowerShell.
- *
- * Windows supports the Node.js fs module fully, so we delegate to the pure
- * Node.js implementation. This provides consistent output formatting that
- * matches the original Unix alias.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_powershell(args) {
-  return do_count_nodejs(args);
-}
-
-/**
- * Count files and folders in Git Bash.
- *
- * Git Bash runs on Windows, and Node.js fs module works correctly here.
- * We delegate to the pure Node.js implementation for consistent behavior.
- *
- * @param {string[]} args - Command line arguments
- * @returns {Promise<void>}
- */
-async function do_count_gitbash(args) {
-  return do_count_nodejs(args);
-}
-
-/**
- * Main entry point - detects environment and executes appropriate implementation.
- *
- * The "count" command displays the number of files and folders in a directory.
- * This is useful for quickly understanding the contents of a directory without
- * having to manually count or use complex shell commands.
- *
- * All platforms use the same pure Node.js implementation because file system
- * operations are fully abstracted by Node.js. The platform detection is still
- * performed to maintain consistency with other scripts in this project.
- *
- * @param {string[]} args - Command line arguments
- * @param {string} [args[0]] - Optional path to count (defaults to current directory)
- * @returns {Promise<void>}
- */
-async function do_count(args) {
-  const platform = os.detect();
-
-  const handlers = {
-    'macos': do_count_macos,
-    'ubuntu': do_count_ubuntu,
-    'debian': do_count_ubuntu,
-    'raspbian': do_count_raspbian,
-    'amazon_linux': do_count_amazon_linux,
-    'rhel': do_count_amazon_linux,
-    'fedora': do_count_ubuntu,
-    'linux': do_count_ubuntu,
-    'wsl': do_count_ubuntu,
-    'cmd': do_count_cmd,
-    'windows': do_count_cmd,
-    'powershell': do_count_powershell,
-    'gitbash': do_count_gitbash
-  };
-
-  const handler = handlers[platform.type];
-  if (!handler) {
-    // For unknown platforms, try the Node.js implementation directly
-    // since it should work anywhere Node.js runs
-    console.error(`Warning: Platform '${platform.type}' is not explicitly supported.`);
-    console.error('Attempting to run with generic Node.js implementation...');
-    console.error('');
-    await do_count_nodejs(args);
-    return;
-  }
-
-  await handler(args);
-}
-
-module.exports = {
-  main: do_count,
-  do_count,
-  do_count_nodejs,
-  do_count_macos,
-  do_count_ubuntu,
-  do_count_raspbian,
-  do_count_amazon_linux,
-  do_count_cmd,
-  do_count_powershell,
-  do_count_gitbash
-};
-
-if (require.main === module) {
-  do_count(process.argv.slice(2));
-}

package/src/scripts/d.js

@@ -1,219 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * d - Navigate to the Desktop directory
- *
- * Migrated from legacy dotfiles alias.
- * Original: alias d="cd ~/Desktop"
- *
- * This script outputs the path to the user's Desktop folder, which can be used
- * with shell integration (e.g., `cd $(d)`). The Desktop folder location varies
- * by operating system:
- * - macOS: ~/Desktop
- * - Linux: ~/Desktop (XDG standard)
- * - Windows: %USERPROFILE%\Desktop
- *
- * @module scripts/d
- */
-
-const os = require('../utils/common/os');
-const path = require('path');
-const fs = require('fs');
-
-/**
- * Pure Node.js implementation that works on any platform.
- *
- * This function determines the Desktop folder path using Node.js APIs.
- * The Desktop folder is typically in the user's home directory, but the
- * exact location can vary. We check for the folder's existence and provide
- * helpful feedback if it doesn't exist.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d_nodejs(args) {
-  // Get the user's home directory using Node.js built-in os module
-  const homeDir = os.getHomeDir();
-
-  // Construct the path to the Desktop folder
-  // On all major platforms, the Desktop folder is named "Desktop" in the home directory
-  const desktopPath = path.join(homeDir, 'Desktop');
-
-  // Check if the Desktop folder exists
-  if (!fs.existsSync(desktopPath)) {
-    // The Desktop folder doesn't exist - this is unusual but can happen
-    // on headless servers or minimal installations
-    console.error(`Error: Desktop folder not found at ${desktopPath}`);
-    console.error('');
-    console.error('This might happen if:');
-    console.error('  - You are on a headless server without a desktop environment');
-    console.error('  - The Desktop folder was deleted or renamed');
-    console.error('  - Your system uses a non-standard Desktop location');
-    console.error('');
-    console.error(`You can create it with: mkdir -p "${desktopPath}"`);
-    process.exit(1);
-  }
-
-  // Output the path so it can be used with shell integration
-  // Example usage: cd $(d)
-  console.log(desktopPath);
-}
-
-/**
- * Navigate to the Desktop folder on macOS.
- *
- * On macOS, the Desktop folder is always at ~/Desktop.
- * This function delegates to the pure Node.js implementation since
- * the logic is identical across platforms.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d_macos(args) {
-  return do_d_nodejs(args);
-}
-
-/**
- * Navigate to the Desktop folder on Ubuntu.
- *
- * On Ubuntu and other Linux distributions following the XDG Base Directory
- * Specification, the Desktop folder is typically at ~/Desktop.
- * This function delegates to the pure Node.js implementation.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d_ubuntu(args) {
-  return do_d_nodejs(args);
-}
-
-/**
- * Navigate to the Desktop folder on Raspberry Pi OS.
- *
- * Raspberry Pi OS follows the same convention as other Debian-based systems.
- * The Desktop folder is at ~/Desktop.
- * This function delegates to the pure Node.js implementation.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d_raspbian(args) {
-  return do_d_nodejs(args);
-}
-
-/**
- * Navigate to the Desktop folder on Amazon Linux.
- *
- * On Amazon Linux (typically used in server environments), a Desktop folder
- * may not exist. This function delegates to the pure Node.js implementation,
- * which will provide helpful feedback if the folder doesn't exist.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d_amazon_linux(args) {
-  return do_d_nodejs(args);
-}
-
-/**
- * Navigate to the Desktop folder on Windows Command Prompt.
- *
- * On Windows, the Desktop folder is at %USERPROFILE%\Desktop.
- * Node.js's os.homedir() correctly returns the USERPROFILE path on Windows,
- * so the pure Node.js implementation works correctly.
- * This function delegates to the pure Node.js implementation.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d_cmd(args) {
-  return do_d_nodejs(args);
-}
-
-/**
- * Navigate to the Desktop folder on Windows PowerShell.
- *
- * On Windows, the Desktop folder is at %USERPROFILE%\Desktop.
- * This function delegates to the pure Node.js implementation.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d_powershell(args) {
-  return do_d_nodejs(args);
-}
-
-/**
- * Navigate to the Desktop folder on Git Bash (Windows).
- *
- * Git Bash runs on Windows, so the Desktop folder is at %USERPROFILE%\Desktop.
- * This function delegates to the pure Node.js implementation.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d_gitbash(args) {
-  return do_d_nodejs(args);
-}
-
-/**
- * Main entry point - detects environment and executes appropriate implementation.
- *
- * The "d" command outputs the path to the user's Desktop folder.
- * This is designed to be used with shell integration:
- *
- *   cd $(d)     # Change to Desktop folder
- *   ls $(d)     # List Desktop contents
- *   cp file $(d)  # Copy file to Desktop
- *
- * The original alias "cd ~/Desktop" directly changed directories, but since
- * Node.js scripts run in a subprocess, they cannot change the parent shell's
- * working directory. Instead, this script outputs the path for the shell to use.
- *
- * @param {string[]} args - Command line arguments (unused)
- * @returns {Promise<void>}
- */
-async function do_d(args) {
-  const platform = os.detect();
-
-  const handlers = {
-    'macos': do_d_macos,
-    'ubuntu': do_d_ubuntu,
-    'debian': do_d_ubuntu,
-    'raspbian': do_d_raspbian,
-    'amazon_linux': do_d_amazon_linux,
-    'rhel': do_d_amazon_linux,
-    'fedora': do_d_ubuntu,
-    'linux': do_d_ubuntu,
-    'wsl': do_d_ubuntu,
-    'cmd': do_d_cmd,
-    'windows': do_d_cmd,
-    'powershell': do_d_powershell,
-    'gitbash': do_d_gitbash
-  };
-
-  const handler = handlers[platform.type];
-  if (!handler) {
-    console.error(`Platform '${platform.type}' is not supported for this command.`);
-    process.exit(1);
-  }
-
-  await handler(args);
-}
-
-module.exports = {
-  main: do_d,
-  do_d,
-  do_d_nodejs,
-  do_d_macos,
-  do_d_ubuntu,
-  do_d_raspbian,
-  do_d_amazon_linux,
-  do_d_cmd,
-  do_d_powershell,
-  do_d_gitbash
-};
-
-if (require.main === module) {
-  do_d(process.argv.slice(2));
-}