@fredlackey/devutils 0.0.1

package/src/commands/ignore.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Ignore command - Append technology-specific patterns to .gitignore.
+ * Reads patterns from src/ignore/*.txt and adds them to the repository's .gitignore.
+ */
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+
+const IGNORE_DIR = path.join(__dirname, '..', 'ignore');
+
+/**
+ * Get list of available ignore technologies
+ * @returns {string[]} Array of technology names
+ */
+function getAvailableTechnologies() {
+  try {
+    if (!fs.existsSync(IGNORE_DIR)) {
+      return [];
+    }
+    return fs.readdirSync(IGNORE_DIR)
+      .filter(file => file.endsWith('.txt'))
+      .map(file => file.replace('.txt', ''))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Find the git root directory by walking up the tree
+ * @param {string} startDir - Starting directory
+ * @returns {string|null} Path to git root or null
+ */
+function findGitRoot(startDir) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+
+  while (currentDir !== root) {
+    const gitDir = path.join(currentDir, '.git');
+    if (fs.existsSync(gitDir)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  return null;
+}
+
+/**
+ * Generate section markers for a technology
+ * @param {string} technology - Technology name
+ * @returns {{ start: string, end: string }}
+ */
+function getSectionMarkers(technology) {
+  return {
+    start: `# === @fredlackey/devutils: ${technology} ===`,
+    end: `# === end: ${technology} ===`
+  };
+}
+
+/**
+ * Check if patterns for a technology are already in .gitignore
+ * @param {string} gitignoreContent - Content of .gitignore
+ * @param {string} technology - Technology name
+ * @returns {boolean}
+ */
+function hasPatterns(gitignoreContent, technology) {
+  const markers = getSectionMarkers(technology);
+  return gitignoreContent.includes(markers.start);
+}
+
+/**
+ * Remove existing patterns for a technology from .gitignore
+ * @param {string} gitignoreContent - Content of .gitignore
+ * @param {string} technology - Technology name
+ * @returns {string} Updated content
+ */
+function removePatterns(gitignoreContent, technology) {
+  const markers = getSectionMarkers(technology);
+  const lines = gitignoreContent.split('\n');
+  const result = [];
+  let inSection = false;
+
+  for (const line of lines) {
+    if (line.trim() === markers.start) {
+      inSection = true;
+      continue;
+    }
+    if (line.trim() === markers.end) {
+      inSection = false;
+      continue;
+    }
+    if (!inSection) {
+      result.push(line);
+    }
+  }
+
+  // Remove trailing empty lines that were before the section
+  while (result.length > 0 && result[result.length - 1] === '') {
+    result.pop();
+  }
+
+  return result.join('\n');
+}
+
+/**
+ * List all available technologies
+ */
+function listTechnologies() {
+  const technologies = getAvailableTechnologies();
+
+  if (technologies.length === 0) {
+    console.log('\nNo ignore patterns available.');
+    console.log(`Pattern files should be placed in: ${IGNORE_DIR}\n`);
+    return;
+  }
+
+  console.log('\nAvailable technologies:');
+  console.log('─'.repeat(40));
+
+  for (const tech of technologies) {
+    console.log(`  ${tech}`);
+  }
+
+  console.log(`\nUsage: dev ignore <technology> [folder]`);
+  console.log('');
+}
+
+/**
+ * Run the ignore command
+ * @param {string} technology - Technology name
+ * @param {string} folder - Optional folder path for .gitignore
+ * @param {object} options - Command options
+ */
+async function runIgnore(technology, folder, options) {
+  // Handle --list option
+  if (options.list) {
+    listTechnologies();
+    return;
+  }
+
+  // Validate technology argument
+  if (!technology) {
+    console.error('\nError: No technology specified.');
+    console.log('Usage: dev ignore <technology> [folder]');
+    console.log('Run `dev ignore --list` to see available options.\n');
+    process.exit(1);
+  }
+
+  // Check if technology pattern file exists
+  const patternFile = path.join(IGNORE_DIR, `${technology}.txt`);
+  if (!fs.existsSync(patternFile)) {
+    console.error(`\nError: Unknown technology "${technology}".`);
+    console.log('Run `dev ignore --list` to see available options.\n');
+    process.exit(1);
+  }
+
+  // Determine target directory for .gitignore
+  let targetDir;
+  if (folder) {
+    // Use specified folder path
+    targetDir = path.resolve(folder);
+    if (!fs.existsSync(targetDir)) {
+      console.error(`\nError: Folder "${folder}" does not exist.\n`);
+      process.exit(1);
+    }
+    if (!fs.statSync(targetDir).isDirectory()) {
+      console.error(`\nError: "${folder}" is not a directory.\n`);
+      process.exit(1);
+    }
+  } else {
+    // Find git root (default behavior)
+    targetDir = findGitRoot(process.cwd());
+    if (!targetDir) {
+      console.error('\nError: No git repository found.');
+      console.log('Initialize with `git init` or specify a folder path.\n');
+      process.exit(1);
+    }
+  }
+
+  const gitignorePath = path.join(targetDir, '.gitignore');
+
+  // Read existing .gitignore content
+  let gitignoreContent = '';
+  if (fs.existsSync(gitignorePath)) {
+    gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+  }
+
+  // Check for existing patterns
+  if (hasPatterns(gitignoreContent, technology)) {
+    if (options.force) {
+      // Remove existing patterns to replace them
+      gitignoreContent = removePatterns(gitignoreContent, technology);
+      console.log(`Replacing existing patterns for ${technology}...`);
+    } else {
+      console.log(`\nPatterns for ${technology} already present in .gitignore`);
+      console.log('Use --force to replace existing patterns.\n');
+      return;
+    }
+  }
+
+  // Read pattern file
+  const patterns = fs.readFileSync(patternFile, 'utf8');
+  const markers = getSectionMarkers(technology);
+
+  // Build the section to add
+  const section = `\n${markers.start}\n${patterns.trim()}\n${markers.end}\n`;
+
+  // Show dry run output
+  if (options.dryRun) {
+    console.log(`\n[Dry run] Would append to ${gitignorePath}:`);
+    console.log('─'.repeat(40));
+    console.log(section);
+    console.log('─'.repeat(40));
+    return;
+  }
+
+  // Append to .gitignore
+  const newContent = gitignoreContent.trimEnd() + section;
+  fs.writeFileSync(gitignorePath, newContent);
+
+  console.log(`\nAdded ${technology} patterns to ${gitignorePath}`);
+
+  // Show what was added (if verbose)
+  if (options.verbose) {
+    console.log('\nPatterns added:');
+    console.log('─'.repeat(40));
+    console.log(patterns.trim());
+    console.log('');
+  }
+}
+
+// Create and configure the command
+const ignore = new Command('ignore')
+  .description('Append technology-specific patterns to .gitignore')
+  .argument('[technology]', 'Technology name (e.g., node, python, macos)')
+  .argument('[folder]', 'Target folder for .gitignore (defaults to git root)')
+  .option('--list', 'List all available technologies')
+  .option('--dry-run', 'Show what would be added without modifying files')
+  .option('--force', 'Re-add patterns even if section already exists')
+  .option('--verbose', 'Show detailed output')
+  .action(runIgnore);
+
+module.exports = ignore;

package/src/commands/install.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Install command - Platform-agnostic installation of development tools.
+ * Locates and executes install scripts from src/installs/.
+ */
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const INSTALLS_DIR = path.join(__dirname, '..', 'installs');
+
+/**
+ * Get list of available install scripts
+ * @returns {string[]} Array of install script names
+ */
+function getAvailableInstalls() {
+  try {
+    if (!fs.existsSync(INSTALLS_DIR)) {
+      return [];
+    }
+    return fs.readdirSync(INSTALLS_DIR)
+      .filter(file => file.endsWith('.js'))
+      .map(file => file.replace('.js', ''))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Prompt user for confirmation
+ * @param {string} question - Question to ask
+ * @returns {Promise<boolean>}
+ */
+function confirm(question) {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(`${question} (y/n): `, answer => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+}
+
+/**
+ * List all available install scripts
+ */
+function listInstalls() {
+  const installs = getAvailableInstalls();
+
+  if (installs.length === 0) {
+    console.log('\nNo install scripts available.');
+    console.log(`Install scripts should be placed in: ${INSTALLS_DIR}\n`);
+    return;
+  }
+
+  console.log('\nAvailable install scripts:');
+  console.log('─'.repeat(40));
+
+  for (const name of installs) {
+    console.log(`  ${name}`);
+  }
+
+  console.log(`\nUsage: dev install <name>`);
+  console.log('');
+}
+
+/**
+ * Run an install script
+ * @param {string} name - Name of the install script
+ * @param {object} options - Command options
+ */
+async function runInstall(name, options) {
+  if (!name) {
+    console.error('\nError: No package specified.');
+    console.log('Usage: dev install <name>');
+    console.log('Run `dev install --list` to see available options.\n');
+    process.exit(1);
+  }
+
+  const scriptPath = path.join(INSTALLS_DIR, `${name}.js`);
+
+  // Check if install script exists
+  if (!fs.existsSync(scriptPath)) {
+    console.error(`\nError: Unknown package "${name}".`);
+    console.log('Run `dev install --list` to see available options.\n');
+    process.exit(1);
+  }
+
+  // Confirm installation (unless --force)
+  if (!options.force) {
+    console.log(`\nPreparing to install: ${name}`);
+
+    if (options.dryRun) {
+      console.log('[Dry run mode - no changes will be made]\n');
+    }
+
+    const shouldProceed = await confirm('Proceed with installation?');
+    if (!shouldProceed) {
+      console.log('Installation cancelled.');
+      return;
+    }
+  }
+
+  try {
+    // Load the install script
+    const installScript = require(scriptPath);
+
+    // Check for install function
+    if (typeof installScript.install !== 'function') {
+      console.error(`\nError: Install script "${name}" does not export an install() function.`);
+      process.exit(1);
+    }
+
+    console.log(`\nInstalling ${name}...`);
+    if (options.verbose) {
+      console.log(`Script: ${scriptPath}`);
+    }
+
+    // Pass options to the install function
+    const installOptions = {
+      dryRun: options.dryRun || false,
+      verbose: options.verbose || false,
+      force: options.force || false
+    };
+
+    // Run the install
+    await installScript.install(installOptions);
+
+    if (!options.dryRun) {
+      console.log(`\n${name} installation complete.`);
+    }
+
+  } catch (err) {
+    console.error(`\nError installing ${name}:`, err.message);
+    if (options.verbose) {
+      console.error(err.stack);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle the install command
+ * @param {string} name - Package name to install
+ * @param {object} options - Command options
+ */
+async function handleInstall(name, options) {
+  if (options.list) {
+    listInstalls();
+    return;
+  }
+
+  await runInstall(name, options);
+}
+
+// Create and configure the command
+const install = new Command('install')
+  .description('Platform-agnostic installation of development tools')
+  .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')
+  .option('--force', 'Skip confirmation prompts')
+  .option('--verbose', 'Show detailed output during installation')
+  .action(handleInstall);
+
+module.exports = install;

package/src/commands/setup.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Setup command - Install essential tools required for DevUtils CLI to function.
+ * This includes git, ssh-keygen, gpg, and other core dependencies.
+ */
+
+const { Command } = require('commander');
+const readline = require('readline');
+
+const shell = require('../utils/common/shell');
+const osUtils = require('../utils/common/os');
+
+// Essential tools that DevUtils CLI requires
+const ESSENTIAL_TOOLS = [
+  {
+    name: 'git',
+    command: 'git',
+    description: 'Version control system',
+    install: 'git'
+  },
+  {
+    name: 'ssh-keygen',
+    command: 'ssh-keygen',
+    description: 'SSH key generation',
+    install: 'openssh'
+  },
+  {
+    name: 'gpg',
+    command: 'gpg',
+    description: 'GPG encryption and signing',
+    install: 'gpg'
+  },
+  {
+    name: 'curl',
+    command: 'curl',
+    description: 'Data transfer tool',
+    install: 'curl'
+  }
+];
+
+/**
+ * Create readline interface for prompts
+ * @returns {readline.Interface}
+ */
+function createPrompt() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Prompt user for confirmation
+ * @param {readline.Interface} rl - Readline interface
+ * @param {string} question - Question to ask
+ * @returns {Promise<boolean>}
+ */
+function confirm(rl, question) {
+  return new Promise(resolve => {
+    rl.question(`${question} (y/n): `, answer => {
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+}
+
+/**
+ * Check which essential tools are missing
+ * @returns {Array<object>} Array of missing tools
+ */
+function checkMissingTools() {
+  const missing = [];
+  for (const tool of ESSENTIAL_TOOLS) {
+    if (!shell.commandExists(tool.command)) {
+      missing.push(tool);
+    }
+  }
+  return missing;
+}
+
+/**
+ * Get all tool statuses
+ * @returns {Array<{ tool: object, installed: boolean }>}
+ */
+function getToolStatuses() {
+  return ESSENTIAL_TOOLS.map(tool => ({
+    tool,
+    installed: shell.commandExists(tool.command)
+  }));
+}
+
+/**
+ * Install a tool using the appropriate installer
+ * @param {object} tool - Tool definition
+ * @returns {Promise<boolean>} True if installation succeeded
+ */
+async function installTool(tool) {
+  try {
+    const installer = require(`../installs/${tool.install}`);
+    if (typeof installer.install === 'function') {
+      return await installer.install();
+    }
+    console.error(`  No install function found for ${tool.name}`);
+    return false;
+  } catch (err) {
+    console.error(`  Failed to install ${tool.name}: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Display tool status table
+ * @param {Array<{ tool: object, installed: boolean }>} statuses
+ */
+function displayToolStatus(statuses) {
+  console.log('\nEssential Tools:');
+  console.log('─'.repeat(50));
+
+  for (const { tool, installed } of statuses) {
+    const status = installed ? '✓ Installed' : '✗ Missing';
+    const statusColor = installed ? status : status;
+    console.log(`  ${tool.name.padEnd(15)} ${statusColor.padEnd(15)} ${tool.description}`);
+  }
+  console.log('');
+}
+
+/**
+ * Run the setup command
+ * @param {object} options - Command options
+ */
+async function runSetup(options) {
+  const platform = osUtils.detect();
+
+  console.log('\n=== DevUtils CLI Setup ===\n');
+  console.log(`Platform: ${platform.type}`);
+  console.log(`Package Manager: ${platform.packageManager || 'unknown'}`);
+
+  // Check tool statuses
+  const statuses = getToolStatuses();
+  displayToolStatus(statuses);
+
+  // Find missing tools
+  const missing = statuses.filter(s => !s.installed).map(s => s.tool);
+
+  if (missing.length === 0) {
+    console.log('All essential tools are already installed.\n');
+    return;
+  }
+
+  console.log(`Missing ${missing.length} tool(s): ${missing.map(t => t.name).join(', ')}\n`);
+
+  // Confirm installation unless --force
+  let shouldInstall = options.force;
+  if (!shouldInstall) {
+    const rl = createPrompt();
+    shouldInstall = await confirm(rl, 'Install missing tools?');
+    rl.close();
+  }
+
+  if (!shouldInstall) {
+    console.log('Setup cancelled.\n');
+    return;
+  }
+
+  // Install each missing tool
+  console.log('\nInstalling missing tools...\n');
+
+  let installed = 0;
+  let failed = 0;
+
+  for (const tool of missing) {
+    console.log(`Installing ${tool.name}...`);
+    const success = await installTool(tool);
+    if (success) {
+      installed++;
+      console.log(`  ${tool.name} installed successfully.\n`);
+    } else {
+      failed++;
+      console.log(`  ${tool.name} installation failed.\n`);
+    }
+  }
+
+  // Show final status
+  console.log('─'.repeat(50));
+  console.log(`\nSetup complete: ${installed} installed, ${failed} failed.\n`);
+
+  // Show updated status
+  if (installed > 0) {
+    const updatedStatuses = getToolStatuses();
+    displayToolStatus(updatedStatuses);
+  }
+}
+
+// Create and configure the command
+const setup = new Command('setup')
+  .description('Install essential tools required for DevUtils CLI')
+  .option('--force', 'Install without prompting')
+  .option('--check', 'Check tool status without installing')
+  .action(async (options) => {
+    if (options.check) {
+      const statuses = getToolStatuses();
+      displayToolStatus(statuses);
+      const missing = statuses.filter(s => !s.installed);
+      if (missing.length > 0) {
+        console.log(`Run 'dev setup' to install missing tools.\n`);
+      }
+      return;
+    }
+    await runSetup(options);
+  });
+
+module.exports = setup;