@fredlackey/devutils 0.0.1 → 0.0.3

package/src/scripts/d.js

@@ -1,23 +1,219 @@
 #!/usr/bin/env node
 
 /**
- * @fileoverview Navigate to the Desktop directory.
+ * 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);
+}
+
 /**
- * Changes the current working directory to the user's Desktop folder.
- * Outputs the path for use with shell integration (e.g., cd $(d)).
+ * 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 main(args) {
-  // TODO: Implement Desktop navigation
+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 };
+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) {
-  main(process.argv.slice(2));
+  do_d(process.argv.slice(2));
 }

package/src/scripts/datauri.js

@@ -1,24 +1,389 @@
 #!/usr/bin/env node
 
 /**
- * @fileoverview Convert file to base64 data URI.
+ * datauri - Convert a file to a base64-encoded data URI string
+ *
+ * Migrated from legacy dotfiles function.
+ * Original:
+ *   datauri() {
+ *       local mimeType=""
+ *       if [ ! -f "$1" ]; then
+ *           printf "%s is not a file.\n" "$1"
+ *           return
+ *       fi
+ *       mimeType=$(file --brief --mime-type "$1")
+ *       if [[ $mimeType == text/* ]]; then
+ *           mimeType="$mimeType;charset=utf-8"
+ *       fi
+ *       printf "data:%s;base64,%s" \
+ *           "$mimeType" \
+ *           "$(openssl base64 -in "$1" | tr -d "\n")"
+ *   }
+ *
+ * This script converts any file to a data URI format that can be embedded
+ * directly in HTML, CSS, or other documents. Data URIs are useful for:
+ * - Embedding small images directly in HTML/CSS
+ * - Avoiding additional HTTP requests
+ * - Creating self-contained HTML files
+ *
  * @module scripts/datauri
  */
 
+const fs = require('fs');
+const path = require('path');
+const os = require('../utils/common/os');
+
+/**
+ * A mapping of common file extensions to their MIME types.
+ * This allows pure Node.js MIME type detection without external dependencies.
+ *
+ * The mapping covers the most common file types used in web development,
+ * images, documents, and media files.
+ */
+const MIME_TYPES = {
+  // Images
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.bmp': 'image/bmp',
+  '.tiff': 'image/tiff',
+  '.tif': 'image/tiff',
+  '.avif': 'image/avif',
+
+  // Audio
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.m4a': 'audio/mp4',
+  '.flac': 'audio/flac',
+  '.aac': 'audio/aac',
+  '.weba': 'audio/webm',
+
+  // Video
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.ogv': 'video/ogg',
+  '.avi': 'video/x-msvideo',
+  '.mov': 'video/quicktime',
+  '.mkv': 'video/x-matroska',
+
+  // Fonts
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.eot': 'application/vnd.ms-fontobject',
+
+  // Text/Code
+  '.html': 'text/html',
+  '.htm': 'text/html',
+  '.css': 'text/css',
+  '.js': 'text/javascript',
+  '.mjs': 'text/javascript',
+  '.json': 'application/json',
+  '.xml': 'application/xml',
+  '.txt': 'text/plain',
+  '.md': 'text/markdown',
+  '.csv': 'text/csv',
+  '.yaml': 'text/yaml',
+  '.yml': 'text/yaml',
+  '.ts': 'text/typescript',
+  '.tsx': 'text/typescript',
+  '.jsx': 'text/javascript',
+
+  // Documents
+  '.pdf': 'application/pdf',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.xls': 'application/vnd.ms-excel',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+
+  // Archives
+  '.zip': 'application/zip',
+  '.tar': 'application/x-tar',
+  '.gz': 'application/gzip',
+  '.rar': 'application/vnd.rar',
+  '.7z': 'application/x-7z-compressed',
+
+  // Other
+  '.wasm': 'application/wasm',
+  '.bin': 'application/octet-stream'
+};
+
+/**
+ * Get the MIME type for a file based on its extension.
+ *
+ * This function uses a built-in mapping of file extensions to MIME types,
+ * which is faster and more portable than calling external tools like `file`.
+ * Falls back to 'application/octet-stream' for unknown extensions.
+ *
+ * @param {string} filePath - The path to the file
+ * @returns {string} The MIME type for the file
+ */
+function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || 'application/octet-stream';
+}
+
 /**
- * Converts a file to a base64-encoded data URI string.
- * Automatically detects the MIME type from the file.
+ * Check if a MIME type represents text content.
+ *
+ * Text content should have charset=utf-8 appended to the MIME type
+ * in data URIs for proper character encoding.
+ *
+ * @param {string} mimeType - The MIME type to check
+ * @returns {boolean} True if the MIME type is text-based
+ */
+function isTextMimeType(mimeType) {
+  // Text types start with 'text/'
+  if (mimeType.startsWith('text/')) {
+    return true;
+  }
+
+  // Some application types are also text-based
+  const textApplicationTypes = [
+    'application/json',
+    'application/xml',
+    'application/javascript',
+    'application/x-javascript'
+  ];
+
+  return textApplicationTypes.includes(mimeType);
+}
+
+/**
+ * Pure Node.js implementation that works on any platform.
+ *
+ * This function reads a file, detects its MIME type based on extension,
+ * encodes the content as base64, and outputs a complete data URI string.
+ *
+ * The data URI format is: data:[<mediatype>][;base64],<data>
+ *
+ * For text content, we append ;charset=utf-8 to the MIME type to ensure
+ * proper character encoding, matching the original bash function behavior.
+ *
+ * @param {string[]} args - Command line arguments, expects file path as first element
+ * @returns {Promise<void>}
+ */
+async function do_datauri_nodejs(args) {
+  // Check if a file path was provided
+  if (!args || args.length === 0) {
+    console.error('Usage: datauri <file>');
+    console.error('');
+    console.error('Convert a file to a base64-encoded data URI string.');
+    console.error('');
+    console.error('Example:');
+    console.error('  datauri image.png');
+    console.error('  datauri styles.css');
+    process.exit(1);
+  }
+
+  const filePath = args[0];
+
+  // Resolve the file path (handles relative paths)
+  const resolvedPath = path.resolve(filePath);
+
+  // Check if the file exists
+  if (!fs.existsSync(resolvedPath)) {
+    console.error(`${filePath} is not a file.`);
+    process.exit(1);
+  }
+
+  // Check if it's actually a file (not a directory)
+  const stats = fs.statSync(resolvedPath);
+  if (!stats.isFile()) {
+    console.error(`${filePath} is not a file.`);
+    process.exit(1);
+  }
+
+  // Get the MIME type based on file extension
+  let mimeType = getMimeType(resolvedPath);
+
+  // For text content, append charset=utf-8 (matching original bash behavior)
+  if (isTextMimeType(mimeType)) {
+    mimeType = `${mimeType};charset=utf-8`;
+  }
+
+  // Read the file contents as a Buffer
+  const fileBuffer = fs.readFileSync(resolvedPath);
+
+  // Convert to base64 string
+  const base64Data = fileBuffer.toString('base64');
+
+  // Output the complete data URI
+  // Using process.stdout.write to avoid trailing newline (matching original printf behavior)
+  process.stdout.write(`data:${mimeType};base64,${base64Data}`);
+}
+
+/**
+ * Convert a file to data URI on macOS.
+ *
+ * macOS can use the pure Node.js implementation since file reading,
+ * MIME type detection, and base64 encoding all work identically.
  *
  * @param {string[]} args - Command line arguments
- * @param {string} args.0 - Path to the file to convert
  * @returns {Promise<void>}
  */
-async function main(args) {
-  // TODO: Implement data URI conversion
+async function do_datauri_macos(args) {
+  return do_datauri_nodejs(args);
+}
+
+/**
+ * Convert a file to data URI on Ubuntu.
+ *
+ * Ubuntu can use the pure Node.js implementation since file reading,
+ * MIME type detection, and base64 encoding all work identically.
+ *
+ * @param {string[]} args - Command line arguments
+ * @returns {Promise<void>}
+ */
+async function do_datauri_ubuntu(args) {
+  return do_datauri_nodejs(args);
+}
+
+/**
+ * Convert a file to data URI on Raspberry Pi OS.
+ *
+ * Raspberry Pi OS can use the pure Node.js implementation since file reading,
+ * MIME type detection, and base64 encoding all work identically.
+ *
+ * @param {string[]} args - Command line arguments
+ * @returns {Promise<void>}
+ */
+async function do_datauri_raspbian(args) {
+  return do_datauri_nodejs(args);
+}
+
+/**
+ * Convert a file to data URI on Amazon Linux.
+ *
+ * Amazon Linux can use the pure Node.js implementation since file reading,
+ * MIME type detection, and base64 encoding all work identically.
+ *
+ * @param {string[]} args - Command line arguments
+ * @returns {Promise<void>}
+ */
+async function do_datauri_amazon_linux(args) {
+  return do_datauri_nodejs(args);
+}
+
+/**
+ * Convert a file to data URI on Windows Command Prompt.
+ *
+ * Windows CMD can use the pure Node.js implementation since file reading,
+ * MIME type detection, and base64 encoding all work identically.
+ * Node.js handles path separators and file system differences automatically.
+ *
+ * @param {string[]} args - Command line arguments
+ * @returns {Promise<void>}
+ */
+async function do_datauri_cmd(args) {
+  return do_datauri_nodejs(args);
+}
+
+/**
+ * Convert a file to data URI on Windows PowerShell.
+ *
+ * Windows PowerShell can use the pure Node.js implementation since file reading,
+ * MIME type detection, and base64 encoding all work identically.
+ * Node.js handles path separators and file system differences automatically.
+ *
+ * @param {string[]} args - Command line arguments
+ * @returns {Promise<void>}
+ */
+async function do_datauri_powershell(args) {
+  return do_datauri_nodejs(args);
+}
+
+/**
+ * Convert a file to data URI on Git Bash.
+ *
+ * Git Bash can use the pure Node.js implementation since file reading,
+ * MIME type detection, and base64 encoding all work identically.
+ * Node.js handles path separators and file system differences automatically.
+ *
+ * @param {string[]} args - Command line arguments
+ * @returns {Promise<void>}
+ */
+async function do_datauri_gitbash(args) {
+  return do_datauri_nodejs(args);
+}
+
+/**
+ * Main entry point - detects environment and executes appropriate implementation.
+ *
+ * The "datauri" command converts any file to a base64-encoded data URI string.
+ * Data URIs embed file contents directly in the string, useful for:
+ * - Embedding small images in HTML img src or CSS background-image
+ * - Avoiding additional HTTP requests for small resources
+ * - Creating self-contained HTML documents
+ *
+ * Usage: datauri <file>
+ *
+ * Example output:
+ *   datauri image.png
+ *   => data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...
+ *
+ *   datauri styles.css
+ *   => data:text/css;charset=utf-8;base64,LyogU3R5bGVz...
+ *
+ * @param {string[]} args - Command line arguments, expects file path as first element
+ * @returns {Promise<void>}
+ */
+async function do_datauri(args) {
+  const platform = os.detect();
+
+  const handlers = {
+    'macos': do_datauri_macos,
+    'ubuntu': do_datauri_ubuntu,
+    'debian': do_datauri_ubuntu,
+    'raspbian': do_datauri_raspbian,
+    'amazon_linux': do_datauri_amazon_linux,
+    'rhel': do_datauri_amazon_linux,
+    'fedora': do_datauri_ubuntu,
+    'linux': do_datauri_ubuntu,
+    'wsl': do_datauri_ubuntu,
+    'cmd': do_datauri_cmd,
+    'windows': do_datauri_cmd,
+    'powershell': do_datauri_powershell,
+    'gitbash': do_datauri_gitbash
+  };
+
+  const handler = handlers[platform.type];
+  if (!handler) {
+    console.error(`Platform '${platform.type}' is not supported for this command.`);
+    console.error('');
+    console.error('Supported platforms:');
+    console.error('  - macOS');
+    console.error('  - Ubuntu, Debian, and other Linux distributions');
+    console.error('  - Raspberry Pi OS');
+    console.error('  - Amazon Linux');
+    console.error('  - Windows (CMD, PowerShell, Git Bash)');
+    process.exit(1);
+  }
+
+  await handler(args);
 }
 
-module.exports = { main };
+module.exports = {
+  main: do_datauri,
+  do_datauri,
+  do_datauri_nodejs,
+  do_datauri_macos,
+  do_datauri_ubuntu,
+  do_datauri_raspbian,
+  do_datauri_amazon_linux,
+  do_datauri_cmd,
+  do_datauri_powershell,
+  do_datauri_gitbash
+};
 
 if (require.main === module) {
-  main(process.argv.slice(2));
+  do_datauri(process.argv.slice(2));
 }