@fredlackey/devutils 0.0.18 → 0.1.0

package/src/commands/util/remove.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const meta = {
+  description: 'Unregister a custom utility. Built-in utilities cannot be removed.',
+  arguments: [
+    { name: 'name', required: true, description: 'Name of the custom utility to remove' },
+  ],
+  flags: [
+    { name: 'confirm', description: 'Skip the confirmation prompt' },
+  ],
+};
+
+async function run(args, context) {
+  const name = args.positional[0];
+  if (!name) {
+    context.errors.throwError(400, 'Usage: dev util remove <name>', 'util');
+    return;
+  }
+
+  // Reject removal of built-in utilities
+  const builtInRegistry = require('../../utils/registry.json');
+  const isBuiltIn = (builtInRegistry.utilities || []).some(u => u.name === name);
+  if (isBuiltIn) {
+    context.output.error(`"${name}" is a built-in utility and cannot be removed.`);
+    return;
+  }
+
+  const customDir = path.join(os.homedir(), '.devutils', 'utils');
+  const folderPath = path.join(customDir, name);
+  const filePath = path.join(customDir, name + '.js');
+
+  const exists = fs.existsSync(folderPath) || fs.existsSync(filePath);
+  if (!exists) {
+    context.output.error(`Custom utility "${name}" not found.`);
+    return;
+  }
+
+  // Ask for confirmation unless --confirm is set
+  if (!args.flags.confirm) {
+    const ok = await context.prompt.confirm(
+      `Remove custom utility "${name}"? This will delete the files.`,
+      false
+    );
+    if (!ok) {
+      context.output.info('Cancelled.');
+      return;
+    }
+  }
+
+  // Delete the files
+  if (fs.existsSync(folderPath)) {
+    fs.rmSync(folderPath, { recursive: true, force: true });
+  } else if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+
+  // Update the custom registry
+  const registryPath = path.join(customDir, 'registry.json');
+  if (fs.existsSync(registryPath)) {
+    try {
+      const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+      registry.utilities = (registry.utilities || []).filter(u => u.name !== name);
+      fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n');
+    } catch {
+      // Registry corrupted, skip update
+    }
+  }
+
+  context.output.info(`Utility "${name}" removed.`);
+}
+
+module.exports = { meta, run };

package/src/commands/util/run.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const builtInDir = path.join(__dirname, '..', '..', 'utils');
+const customDir = path.join(os.homedir(), '.devutils', 'utils');
+
+const meta = {
+  description: 'Execute a utility by name. Extra arguments are passed through to the utility.',
+  arguments: [
+    { name: 'name', required: true, description: 'Name of the utility to run' },
+  ],
+  flags: [],
+};
+
+/**
+ * Find a utility by name, checking built-in first, then custom.
+ * Supports both folder-based (name/index.js) and single-file (name.js) utilities.
+ *
+ * @param {string} name - The utility name.
+ * @returns {{ path: string, type: string }|null} The utility location, or null if not found.
+ */
+function findUtility(name) {
+  // Check built-in: folder with index.js
+  const builtInFolder = path.join(builtInDir, name, 'index.js');
+  if (fs.existsSync(builtInFolder)) {
+    return { path: builtInFolder, type: 'built-in' };
+  }
+
+  // Check built-in: single file
+  const builtInFile = path.join(builtInDir, name + '.js');
+  if (fs.existsSync(builtInFile)) {
+    return { path: builtInFile, type: 'built-in' };
+  }
+
+  // Check custom: folder with index.js
+  const customFolder = path.join(customDir, name, 'index.js');
+  if (fs.existsSync(customFolder)) {
+    return { path: customFolder, type: 'custom' };
+  }
+
+  // Check custom: single file
+  const customFile = path.join(customDir, name + '.js');
+  if (fs.existsSync(customFile)) {
+    return { path: customFile, type: 'custom' };
+  }
+
+  return null;
+}
+
+async function run(args, context) {
+  const name = args.positional[0];
+  if (!name) {
+    context.errors.throwError(400, 'Usage: dev util run <name> [args...]', 'util');
+    return;
+  }
+
+  const utilArgs = args.positional.slice(1);
+
+  const util = findUtility(name);
+  if (!util) {
+    context.output.error(`Utility "${name}" not found.`);
+    context.output.info('Run "dev util list" to see available utilities.');
+    return;
+  }
+
+  const utilModule = require(util.path);
+
+  if (typeof utilModule.run !== 'function') {
+    context.output.error(`Utility "${name}" does not export a run() function.`);
+    return;
+  }
+
+  await utilModule.run(utilArgs, context);
+}
+
+module.exports = { meta, run, findUtility };

package/src/commands/util/show.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const meta = {
+  description: 'Show details, supported platforms, and accepted arguments for a utility.',
+  arguments: [
+    { name: 'name', required: true, description: 'Name of the utility to inspect' },
+  ],
+  flags: [],
+};
+
+async function run(args, context) {
+  const name = args.positional[0];
+  if (!name) {
+    context.errors.throwError(400, 'Usage: dev util show <name>', 'util');
+    return;
+  }
+
+  const { findUtility } = require('./run');
+  const util = findUtility(name);
+
+  if (!util) {
+    context.errors.throwError(404, `Utility "${name}" not found. Run "dev util list" to see available utilities.`, 'util');
+    return;
+  }
+
+  const utilModule = require(util.path);
+  const utilMeta = utilModule.meta || {};
+
+  const info = {
+    name: utilMeta.name || name,
+    description: utilMeta.description || '(no description)',
+    type: util.type,
+    platforms: utilMeta.platforms || [],
+    arguments: utilMeta.arguments || [],
+    flags: utilMeta.flags || [],
+  };
+
+  if (context.flags.format === 'json') {
+    context.output.out(info);
+    return;
+  }
+
+  context.output.info(`Utility: ${info.name}`);
+  context.output.info('');
+  context.output.info(`  Description: ${info.description}`);
+  context.output.info(`  Type:        ${info.type}`);
+  context.output.info(`  Platforms:   ${info.platforms.length > 0 ? info.platforms.join(', ') : '(all)'}`);
+
+  if (info.arguments.length > 0) {
+    context.output.info('');
+    context.output.info('  Arguments:');
+    for (const arg of info.arguments) {
+      const req = arg.required ? '(required)' : '(optional)';
+      context.output.info(`    ${arg.name} ${req} - ${arg.description || ''}`);
+    }
+  }
+
+  if (info.flags.length > 0) {
+    context.output.info('');
+    context.output.info('  Flags:');
+    for (const flag of info.flags) {
+      context.output.info(`    --${flag.name} - ${flag.description || ''}`);
+    }
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/version.js

@@ -1,100 +1,33 @@
-#!/usr/bin/env node
+'use strict';
 
 /**
- * @fileoverview Version command - Display current version and check for updates.
- * Queries the NPM registry to determine if a newer version is available.
+ * version command.
+ * Reads the version string from package.json and prints it.
+ * When format is json, outputs { version: "x.y.z" }.
+ * When table/tty, outputs just the version string.
  */
 
-const { Command } = require('commander');
-const { execSync } = require('child_process');
-const pkg = require('../../package.json');
+const meta = {
+  description: 'Show the current installed version',
+  arguments: [],
+  flags: []
+};
 
 /**
- * The name of this package on NPM
+ * Prints the current DevUtils CLI version.
+ *
+ * @param {object} args - Parsed command arguments (none expected).
+ * @param {object} context - The CLI context object with output, flags, etc.
  */
-const PACKAGE_NAME = pkg.name;
+async function run(args, context) {
+  const pkg = require('../../package.json');
+  const version = pkg.version;
 
-/**
- * Get the latest version of this package from the NPM registry
- * @returns {string|null} The latest version string, or null if unable to fetch
- */
-function getLatestVersion() {
-  try {
-    const result = execSync(`npm view ${PACKAGE_NAME} version`, {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-    return result.trim();
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Compare two semantic version strings
- * @param {string} current - Current version (e.g., "1.2.3")
- * @param {string} latest - Latest version (e.g., "1.2.4")
- * @returns {boolean} True if latest is newer than current
- */
-function isNewerVersion(current, latest) {
-  if (!current || !latest) {
-    return false;
-  }
-
-  const currentParts = current.split('.').map(Number);
-  const latestParts = latest.split('.').map(Number);
-
-  for (let i = 0; i < 3; i++) {
-    const currentPart = currentParts[i] || 0;
-    const latestPart = latestParts[i] || 0;
-
-    if (latestPart > currentPart) {
-      return true;
-    }
-    if (latestPart < currentPart) {
-      return false;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Display version information and check for updates
- * @param {object} options - Command options
- */
-async function runVersion(options) {
-  const currentVersion = pkg.version;
-
-  console.log(`\n${pkg.name}`);
-  console.log('─'.repeat(40));
-  console.log(`Current version: ${currentVersion}`);
-
-  // Check for updates
-  console.log('\nChecking for updates...');
-  const latestVersion = getLatestVersion();
-
-  if (!latestVersion) {
-    console.log('Unable to check for updates (NPM registry unreachable)');
-    console.log('');
-    return;
-  }
-
-  if (isNewerVersion(currentVersion, latestVersion)) {
-    console.log(`\nUpdate available: ${currentVersion} -> ${latestVersion}`);
-    console.log('\nTo update, run:');
-    console.log('  dev update');
-    console.log('');
+  if (context.flags.format === 'json') {
+    context.output.out({ version });
   } else {
-    console.log(`Latest version:  ${latestVersion}`);
-    console.log('\nYou are running the latest version.');
-    console.log('');
+    context.output.info(version);
   }
 }
 
-// Create and configure the command
-const version = new Command('version')
-  .description('Display current version and check for updates')
-  .action(runVersion);
-
-module.exports = version;
+module.exports = { meta, run };

package/src/installers/_template.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Installer: <TOOL_NAME>
+ *
+ * Installs <TOOL_NAME> on supported platforms.
+ * See registry.json for platform support and dependencies.
+ */
+
+/**
+ * Check if <TOOL_NAME> is already installed.
+ * @param {object} context - The CLI context object (has platform, shell, output, etc.)
+ * @returns {Promise<boolean>} true if the tool is available on the system
+ */
+async function isInstalled(context) {
+  // Use context.shell to check if the binary exists on the PATH.
+  // Example: return context.shell.commandExists('<binary-name>');
+  return false;
+}
+
+/**
+ * Install on macOS using Homebrew.
+ * @param {object} context - The CLI context object
+ */
+async function install_macos(context) {
+  // Example: await context.shell.exec('brew install <tool>');
+  throw new Error('install_macos not implemented');
+}
+
+/**
+ * Install on Ubuntu using apt.
+ * @param {object} context - The CLI context object
+ */
+async function install_ubuntu(context) {
+  throw new Error('install_ubuntu not implemented');
+}
+
+/**
+ * Install on Raspberry Pi OS using apt.
+ * @param {object} context - The CLI context object
+ */
+async function install_raspbian(context) {
+  throw new Error('install_raspbian not implemented');
+}
+
+/**
+ * Install on Amazon Linux using dnf/yum.
+ * @param {object} context - The CLI context object
+ */
+async function install_amazon_linux(context) {
+  throw new Error('install_amazon_linux not implemented');
+}
+
+/**
+ * Install on Windows using Chocolatey or winget.
+ * @param {object} context - The CLI context object
+ */
+async function install_windows(context) {
+  throw new Error('install_windows not implemented');
+}
+
+/**
+ * Install in Git Bash (manual or portable install).
+ * @param {object} context - The CLI context object
+ */
+async function install_gitbash(context) {
+  throw new Error('install_gitbash not implemented');
+}
+
+/**
+ * Main install dispatcher. Detects the platform and calls the right function.
+ * The framework calls this -- you don't need to call it directly.
+ * @param {object} context - The CLI context object
+ */
+async function install(context) {
+  const platformType = context.platform.detect().type;
+  const installers = {
+    'macos': install_macos,
+    'ubuntu': install_ubuntu,
+    'raspbian': install_raspbian,
+    'amazon-linux': install_amazon_linux,
+    'windows': install_windows,
+    'gitbash': install_gitbash,
+  };
+
+  const fn = installers[platformType];
+  if (!fn) {
+    throw new Error(`No installer for platform: ${platformType}`);
+  }
+
+  await fn(context);
+}
+
+module.exports = {
+  isInstalled,
+  install,
+  install_macos,
+  install_ubuntu,
+  install_raspbian,
+  install_amazon_linux,
+  install_windows,
+  install_gitbash,
+};

package/src/installers/git.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Installer: git
+ *
+ * Installs git on all supported platforms.
+ * See registry.json for platform support and dependencies.
+ */
+
+/**
+ * Check if git is already installed.
+ * @param {object} context - The CLI context object (has platform, shell, output, etc.)
+ * @returns {Promise<boolean>} true if git is available on the system
+ */
+async function isInstalled(context) {
+  return context.shell.commandExists('git');
+}
+
+/**
+ * Get the installed git version.
+ * @param {object} context - The CLI context object
+ * @returns {Promise<string|null>} Version string like '2.43.0', or null if unavailable.
+ */
+async function getVersion(context) {
+  try {
+    const result = await context.shell.exec('git --version');
+    // Output looks like: "git version 2.43.0" or "git version 2.43.0.windows.1"
+    const match = result.stdout.trim().match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Install git on macOS using Homebrew.
+ * @param {object} context - The CLI context object
+ */
+async function install_macos(context) {
+  if (!context.shell.commandExists('brew')) {
+    throw new Error(
+      'Homebrew is not installed. Run "dev tools install homebrew" first, or install git manually.'
+    );
+  }
+  await context.shell.exec('brew install git');
+}
+
+/**
+ * Install git on Ubuntu using apt.
+ * @param {object} context - The CLI context object
+ */
+async function install_ubuntu(context) {
+  await context.shell.exec('sudo apt-get update');
+  await context.shell.exec('sudo apt-get install -y git');
+}
+
+/**
+ * Install git on Raspberry Pi OS using apt.
+ * @param {object} context - The CLI context object
+ */
+async function install_raspbian(context) {
+  await context.shell.exec('sudo apt-get update');
+  await context.shell.exec('sudo apt-get install -y git');
+}
+
+/**
+ * Install git on Amazon Linux using dnf or yum.
+ * @param {object} context - The CLI context object
+ */
+async function install_amazon_linux(context) {
+  const hasDnf = context.shell.commandExists('dnf');
+  if (hasDnf) {
+    await context.shell.exec('sudo dnf install -y git');
+  } else {
+    await context.shell.exec('sudo yum install -y git');
+  }
+}
+
+/**
+ * Install git on Windows using Chocolatey or winget.
+ * @param {object} context - The CLI context object
+ */
+async function install_windows(context) {
+  const hasChoco = context.shell.commandExists('choco');
+  const hasWinget = context.shell.commandExists('winget');
+
+  if (hasChoco) {
+    await context.shell.exec('choco install git -y');
+  } else if (hasWinget) {
+    await context.shell.exec(
+      'winget install --id Git.Git --accept-package-agreements --accept-source-agreements'
+    );
+  } else {
+    throw new Error(
+      'Neither Chocolatey nor winget is available. Install one of them first, or download git from https://git-scm.com'
+    );
+  }
+}
+
+/**
+ * Install git in Git Bash. Git Bash ships with git, so this is a no-op.
+ * @param {object} context - The CLI context object
+ */
+async function install_gitbash(context) {
+  if (await isInstalled(context)) {
+    context.output.info('Git is already available in Git Bash.');
+    return;
+  }
+  // This shouldn't happen -- Git Bash IS git. But just in case:
+  throw new Error(
+    'Git not found in Git Bash environment. This is unexpected. Reinstall Git for Windows from https://git-scm.com'
+  );
+}
+
+/**
+ * Main install dispatcher. Detects the platform and calls the right function.
+ * The framework calls this -- you don't need to call it directly.
+ * @param {object} context - The CLI context object
+ */
+async function install(context) {
+  const platformType = context.platform.detect().type;
+  const installers = {
+    'macos': install_macos,
+    'ubuntu': install_ubuntu,
+    'raspbian': install_raspbian,
+    'amazon-linux': install_amazon_linux,
+    'windows': install_windows,
+    'gitbash': install_gitbash,
+  };
+
+  const fn = installers[platformType];
+  if (!fn) {
+    throw new Error(`No installer for platform: ${platformType}`);
+  }
+
+  await fn(context);
+}
+
+module.exports = {
+  isInstalled,
+  install,
+  getVersion,
+  install_macos,
+  install_ubuntu,
+  install_raspbian,
+  install_amazon_linux,
+  install_windows,
+  install_gitbash,
+};