@fredlackey/devutils 0.0.1 → 0.0.3

package/src/scripts/s.js

@@ -1,24 +1,540 @@
 #!/usr/bin/env node
 
 /**
- * @fileoverview Search text in current directory.
+ * s - Recursively search for text in the current directory
+ *
+ * Migrated from legacy dotfiles alias.
+ * Original:
+ *   s() {
+ *       grep --color=always "$*" \
+ *            --exclude-dir=".git" \
+ *            --exclude-dir="node_modules" \
+ *            --ignore-case \
+ *            --recursive \
+ *            . \
+ *           | less --no-init --raw-control-chars
+ *   }
+ *
+ * This script provides a quick way to search for text patterns recursively
+ * in the current directory. It automatically excludes common directories
+ * like .git and node_modules that typically contain files you don't want
+ * to search through.
+ *
+ * Usage:
+ *   s "search pattern"
+ *   s my_variable
+ *   s "function.*async"    # regex patterns work
+ *
+ * The search is case-insensitive and results are displayed with color
+ * highlighting, piped through a pager for easy navigation.
+ *
  * @module scripts/s
  */
 
+const os = require('../utils/common/os');
+const { execSync, spawnSync } = require('child_process');
+
+/**
+ * Directories to exclude from search.
+ * These are common directories that contain generated or dependency files
+ * that are usually not relevant when searching source code.
+ */
+const EXCLUDE_DIRS = [
+  '.git',
+  'node_modules',
+  '.next',
+  'dist',
+  'build',
+  '.cache',
+  'coverage',
+  '__pycache__',
+  '.pytest_cache',
+  'vendor',
+  'target'
+];
+
+/**
+ * Helper function to check if a command exists on the system.
+ *
+ * @param {string} cmd - The command name to check
+ * @returns {boolean} True if the command exists, false otherwise
+ */
+function isCommandAvailable(cmd) {
+  try {
+    const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
+    execSync(checkCmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Pure Node.js implementation - NOT RECOMMENDED for this script.
+ *
+ * While we could implement text search in pure Node.js using fs.readdir,
+ * fs.readFile, and regex matching, the native grep command is:
+ * - Much faster for large directory trees
+ * - Better at handling binary files gracefully
+ * - Optimized for streaming large files
+ * - Already handles edge cases (symlinks, permissions, etc.)
+ *
+ * This function exists for environments where grep is not available,
+ * but it may be slower for large searches.
+ *
+ * @param {string[]} args - Command line arguments (search pattern)
+ * @returns {Promise<void>}
+ */
+async function do_s_nodejs(args) {
+  const fs = require('fs');
+  const path = require('path');
+
+  if (args.length === 0) {
+    console.error('Usage: s <search-pattern>');
+    console.error('');
+    console.error('Recursively searches for text matching the pattern');
+    console.error('in the current directory, excluding .git and node_modules.');
+    console.error('');
+    console.error('Examples:');
+    console.error('  s "my_variable"');
+    console.error('  s "TODO"');
+    console.error('  s "function.*async"');
+    process.exit(1);
+  }
+
+  // Join all arguments into a single search pattern
+  // This matches the bash behavior of "$*"
+  const pattern = args.join(' ');
+  const regex = new RegExp(pattern, 'i'); // case-insensitive
+
+  // Track results for output
+  const results = [];
+
+  /**
+   * Recursively walk a directory and search files for the pattern.
+   *
+   * @param {string} dir - Directory to search
+   */
+  function walkDir(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      // Skip directories we can't read (permissions, etc.)
+      return;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Skip excluded directories
+        if (EXCLUDE_DIRS.includes(entry.name)) {
+          continue;
+        }
+        // Recurse into subdirectory
+        walkDir(fullPath);
+      } else if (entry.isFile()) {
+        // Search file for pattern
+        searchFile(fullPath);
+      }
+    }
+  }
+
+  /**
+   * Search a single file for the pattern and add matches to results.
+   *
+   * @param {string} filePath - Path to the file to search
+   */
+  function searchFile(filePath) {
+    let content;
+    try {
+      // Read file as UTF-8 text
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch (err) {
+      // Skip files we can't read (binary, permissions, etc.)
+      return;
+    }
+
+    // Check if file appears to be binary (contains null bytes)
+    if (content.includes('\0')) {
+      return;
+    }
+
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (regex.test(lines[i])) {
+        // Format: filename:linenum:content (like grep)
+        const relativePath = path.relative(process.cwd(), filePath);
+        results.push({
+          file: relativePath,
+          line: i + 1,
+          content: lines[i]
+        });
+      }
+    }
+  }
+
+  // Start the search from current directory
+  walkDir(process.cwd());
+
+  // Output results
+  if (results.length === 0) {
+    console.log('No matches found.');
+    return;
+  }
+
+  // Output in grep-like format with color highlighting
+  for (const result of results) {
+    // Highlight the matching portion
+    const highlighted = result.content.replace(
+      regex,
+      (match) => `\x1b[1;31m${match}\x1b[0m` // Red and bold
+    );
+    console.log(`\x1b[35m${result.file}\x1b[0m:\x1b[32m${result.line}\x1b[0m:${highlighted}`);
+  }
+}
+
+/**
+ * Search for text on macOS using grep and less.
+ *
+ * macOS ships with BSD grep by default, but if the user has installed
+ * GNU grep via Homebrew (as ggrep), we'll use that for better compatibility.
+ *
+ * @param {string[]} args - Command line arguments (search pattern)
+ * @returns {Promise<void>}
+ */
+async function do_s_macos(args) {
+  if (args.length === 0) {
+    console.error('Usage: s <search-pattern>');
+    console.error('');
+    console.error('Recursively searches for text matching the pattern');
+    console.error('in the current directory, excluding .git and node_modules.');
+    process.exit(1);
+  }
+
+  // Build the search pattern (join all args like bash "$*")
+  const pattern = args.join(' ');
+
+  // Build exclude-dir flags for grep
+  const excludeFlags = EXCLUDE_DIRS.map(d => `--exclude-dir="${d}"`).join(' ');
+
+  // Use ggrep (GNU grep) if available, otherwise BSD grep
+  // GNU grep has better regex support and color handling
+  const grepCmd = isCommandAvailable('ggrep') ? 'ggrep' : 'grep';
+
+  // Build the full command matching the original alias behavior
+  const command = `${grepCmd} --color=always "${pattern}" ${excludeFlags} --ignore-case --recursive . 2>/dev/null | less --no-init --raw-control-chars`;
+
+  try {
+    // Use spawnSync with shell:true and inherit stdio to handle piping and less
+    spawnSync('sh', ['-c', command], {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+  } catch (error) {
+    // grep returns exit code 1 if no matches found, which is not an error
+    // Only report errors that are actual failures
+    if (error.status && error.status > 1) {
+      console.error('Error: Search failed.');
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Search for text on Ubuntu using grep and less.
+ *
+ * Ubuntu includes GNU grep and less by default, so we can use
+ * the exact same command as the original dotfiles alias.
+ *
+ * @param {string[]} args - Command line arguments (search pattern)
+ * @returns {Promise<void>}
+ */
+async function do_s_ubuntu(args) {
+  if (args.length === 0) {
+    console.error('Usage: s <search-pattern>');
+    console.error('');
+    console.error('Recursively searches for text matching the pattern');
+    console.error('in the current directory, excluding .git and node_modules.');
+    process.exit(1);
+  }
+
+  // Build the search pattern
+  const pattern = args.join(' ');
+
+  // Build exclude-dir flags
+  const excludeFlags = EXCLUDE_DIRS.map(d => `--exclude-dir="${d}"`).join(' ');
+
+  // Build the command exactly like the original alias
+  const command = `grep --color=always "${pattern}" ${excludeFlags} --ignore-case --recursive . 2>/dev/null | less --no-init --raw-control-chars`;
+
+  try {
+    spawnSync('sh', ['-c', command], {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+  } catch (error) {
+    if (error.status && error.status > 1) {
+      console.error('Error: Search failed.');
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Search for text on Raspberry Pi OS using grep and less.
+ *
+ * Raspberry Pi OS is Debian-based and includes grep and less.
+ * Uses the same implementation as Ubuntu.
+ *
+ * @param {string[]} args - Command line arguments (search pattern)
+ * @returns {Promise<void>}
+ */
+async function do_s_raspbian(args) {
+  // Raspberry Pi OS has the same tools as Ubuntu
+  return do_s_ubuntu(args);
+}
+
+/**
+ * Search for text on Amazon Linux using grep and less.
+ *
+ * Amazon Linux includes GNU grep and less by default.
+ * Uses the same implementation as Ubuntu.
+ *
+ * @param {string[]} args - Command line arguments (search pattern)
+ * @returns {Promise<void>}
+ */
+async function do_s_amazon_linux(args) {
+  // Amazon Linux has the same tools as Ubuntu
+  return do_s_ubuntu(args);
+}
+
+/**
+ * Search for text on Windows Command Prompt.
+ *
+ * Windows CMD doesn't have grep or less by default. We check for:
+ * 1. Git's grep (included with Git for Windows)
+ * 2. findstr (native Windows command, limited functionality)
+ *
+ * If neither is suitable, we fall back to the Node.js implementation.
+ *
+ * @param {string[]} args - Command line arguments (search pattern)
+ * @returns {Promise<void>}
+ */
+async function do_s_cmd(args) {
+  if (args.length === 0) {
+    console.error('Usage: s <search-pattern>');
+    console.error('');
+    console.error('Recursively searches for text matching the pattern');
+    console.error('in the current directory, excluding .git and node_modules.');
+    process.exit(1);
+  }
+
+  // Check if Git for Windows is installed (includes grep)
+  // Git's grep is available at Git/usr/bin/grep.exe
+  if (isCommandAvailable('grep')) {
+    const pattern = args.join(' ');
+    const excludeFlags = EXCLUDE_DIRS.map(d => `--exclude-dir="${d}"`).join(' ');
+
+    // Use grep with less if available, otherwise just grep
+    let command;
+    if (isCommandAvailable('less')) {
+      command = `grep --color=always "${pattern}" ${excludeFlags} --ignore-case --recursive . 2>nul | less --no-init --raw-control-chars`;
+    } else {
+      // Without less, just output directly (may be a lot of output)
+      command = `grep --color=always "${pattern}" ${excludeFlags} --ignore-case --recursive . 2>nul`;
+    }
+
+    try {
+      spawnSync('cmd', ['/c', command], {
+        stdio: 'inherit',
+        cwd: process.cwd()
+      });
+      return;
+    } catch (error) {
+      // Fall through to Node.js implementation
+    }
+  }
+
+  // Fallback: use findstr (native Windows, but limited)
+  // findstr doesn't support excluding directories, so use Node.js instead
+  console.log('Note: Using Node.js search (install Git for Windows for faster grep-based search)');
+  return do_s_nodejs(args);
+}
+
+/**
+ * Search for text on Windows PowerShell.
+ *
+ * PowerShell has Select-String which is similar to grep, but we prefer
+ * grep if available (from Git for Windows) for consistency.
+ *
+ * @param {string[]} args - Command line arguments (search pattern)
+ * @returns {Promise<void>}
+ */
+async function do_s_powershell(args) {
+  if (args.length === 0) {
+    console.error('Usage: s <search-pattern>');
+    console.error('');
+    console.error('Recursively searches for text matching the pattern');
+    console.error('in the current directory, excluding .git and node_modules.');
+    process.exit(1);
+  }
+
+  // Check if grep is available (from Git for Windows)
+  if (isCommandAvailable('grep')) {
+    const pattern = args.join(' ');
+    const excludeFlags = EXCLUDE_DIRS.map(d => `--exclude-dir="${d}"`).join(' ');
+
+    let command;
+    if (isCommandAvailable('less')) {
+      command = `grep --color=always "${pattern}" ${excludeFlags} --ignore-case --recursive . 2>$null | less --no-init --raw-control-chars`;
+    } else {
+      command = `grep --color=always "${pattern}" ${excludeFlags} --ignore-case --recursive . 2>$null`;
+    }
+
+    try {
+      spawnSync('powershell', ['-Command', command], {
+        stdio: 'inherit',
+        cwd: process.cwd()
+      });
+      return;
+    } catch (error) {
+      // Fall through to Select-String or Node.js
+    }
+  }
+
+  // Use PowerShell's Select-String as fallback
+  // Select-String is similar to grep but with different syntax
+  const pattern = args.join(' ');
+
+  // Build the exclude pattern for Where-Object
+  const excludePattern = EXCLUDE_DIRS.map(d => `'*\\${d}\\*'`).join(',');
+
+  // PowerShell command using Select-String
+  // Note: We use single quotes and escape sequences that PowerShell understands
+  const excludeRegex = EXCLUDE_DIRS.join('|');
+  const psCommand = [
+    'Get-ChildItem -Recurse -File |',
+    `Where-Object { $_.FullName -notmatch '(${excludeRegex})' } |`,
+    `Select-String -Pattern '${pattern}' -CaseSensitive:$false |`,
+    'ForEach-Object {',
+    '  $relativePath = $_.Path.Replace((Get-Location).Path + "\\", "")',
+    '  $lineNum = $_.LineNumber',
+    '  $lineText = $_.Line',
+    '  Write-Host "$relativePath`:$lineNum`:$lineText"',
+    '} |',
+    'Out-Host -Paging'
+  ].join(' ');
+
+  try {
+    spawnSync('powershell', ['-Command', psCommand], {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+  } catch (error) {
+    // Fall back to Node.js if PowerShell command fails
+    console.log('Note: Using Node.js search implementation');
+    return do_s_nodejs(args);
+  }
+}
+
+/**
+ * Search for text in Git Bash on Windows.
+ *
+ * Git Bash includes GNU grep and less, so we can use the same
+ * command as on Linux/macOS.
+ *
+ * @param {string[]} args - Command line arguments (search pattern)
+ * @returns {Promise<void>}
+ */
+async function do_s_gitbash(args) {
+  if (args.length === 0) {
+    console.error('Usage: s <search-pattern>');
+    console.error('');
+    console.error('Recursively searches for text matching the pattern');
+    console.error('in the current directory, excluding .git and node_modules.');
+    process.exit(1);
+  }
+
+  // Git Bash has grep and less
+  const pattern = args.join(' ');
+  const excludeFlags = EXCLUDE_DIRS.map(d => `--exclude-dir="${d}"`).join(' ');
+
+  const command = `grep --color=always "${pattern}" ${excludeFlags} --ignore-case --recursive . 2>/dev/null | less --no-init --raw-control-chars`;
+
+  try {
+    spawnSync('sh', ['-c', command], {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+  } catch (error) {
+    if (error.status && error.status > 1) {
+      console.error('Error: Search failed.');
+      process.exit(1);
+    }
+  }
+}
+
 /**
- * Recursively searches for text matching the specified pattern
- * in the current directory, excluding .git and node_modules.
+ * Main entry point - detects environment and executes appropriate implementation.
+ *
+ * The "s" command provides a quick way to search for text patterns recursively
+ * in the current directory. It's designed to be a faster, more ergonomic
+ * alternative to typing out the full grep command with exclude flags.
+ *
+ * Features:
+ * - Recursive search through all subdirectories
+ * - Excludes common directories (.git, node_modules, etc.)
+ * - Case-insensitive matching
+ * - Color-highlighted results
+ * - Paged output through less (on supported platforms)
  *
- * @param {string[]} args - Command line arguments
- * @param {string} args.0 - Search pattern
+ * @param {string[]} args - Command line arguments (search pattern)
  * @returns {Promise<void>}
  */
-async function main(args) {
-  // TODO: Implement recursive text search
+async function do_s(args) {
+  const platform = os.detect();
+
+  const handlers = {
+    'macos': do_s_macos,
+    'ubuntu': do_s_ubuntu,
+    'debian': do_s_ubuntu,
+    'raspbian': do_s_raspbian,
+    'amazon_linux': do_s_amazon_linux,
+    'rhel': do_s_amazon_linux,
+    'fedora': do_s_ubuntu,
+    'linux': do_s_ubuntu,
+    'wsl': do_s_ubuntu,
+    'cmd': do_s_cmd,
+    'windows': do_s_cmd,
+    'powershell': do_s_powershell,
+    'gitbash': do_s_gitbash
+  };
+
+  const handler = handlers[platform.type];
+  if (!handler) {
+    // For unknown platforms, try the Node.js implementation
+    console.log(`Note: Platform '${platform.type}' using Node.js search implementation`);
+    return do_s_nodejs(args);
+  }
+
+  await handler(args);
 }
 
-module.exports = { main };
+module.exports = {
+  main: do_s,
+  do_s,
+  do_s_nodejs,
+  do_s_macos,
+  do_s_ubuntu,
+  do_s_raspbian,
+  do_s_amazon_linux,
+  do_s_cmd,
+  do_s_powershell,
+  do_s_gitbash
+};
 
 if (require.main === module) {
-  main(process.argv.slice(2));
+  do_s(process.argv.slice(2));
 }