@fredlackey/devutils 0.0.18 → 0.1.0

package/src/commands/tools/list.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * Command: dev tools list
+ *
+ * Lists all available tools from the registry, with their install status.
+ * Can filter by --installed, --available, or --platform.
+ */
+
+/**
+ * @type {{ description: string, arguments: Array, flags: Array }}
+ */
+const meta = {
+  description: 'List available tools',
+  arguments: [],
+  flags: [
+    { name: '--installed', description: 'Show only installed tools' },
+    { name: '--available', description: 'Show only tools not yet installed' },
+    { name: '--platform', description: 'Filter by platform (default: current)' }
+  ]
+};
+
+/**
+ * Runs the list command.
+ * @param {{ positional: string[], flags: object }} args - Parsed command arguments.
+ * @param {object} context - The CLI context object.
+ */
+async function run(args, context) {
+  const installer = require('../../lib/installer');
+
+  // Load the full registry
+  const tools = installer.loadRegistry();
+
+  // Determine platform filter
+  const platformFilter = args.flags.platform || context.platform.detect().type;
+
+  // Filter to tools that support the target platform
+  let filtered = tools.filter(t => t.platforms.includes(platformFilter));
+
+  // If --installed or --available, check each tool's install status
+  const showInstalled = args.flags.installed === true;
+  const showAvailable = args.flags.available === true;
+
+  if (showInstalled || showAvailable) {
+    const statusResults = [];
+    for (const tool of filtered) {
+      try {
+        const mod = installer.loadInstaller(tool);
+        const isInst = await mod.isInstalled(context);
+        statusResults.push({ tool, installed: isInst });
+      } catch {
+        // If the installer can't be loaded, treat as not installed
+        statusResults.push({ tool, installed: false });
+      }
+    }
+
+    if (showInstalled) {
+      filtered = statusResults.filter(r => r.installed).map(r => r.tool);
+    } else {
+      filtered = statusResults.filter(r => !r.installed).map(r => r.tool);
+    }
+  }
+
+  if (filtered.length === 0) {
+    context.output.info('No tools match the current filters.');
+    return;
+  }
+
+  // Build output rows with install status
+  const rows = [];
+  for (const tool of filtered) {
+    let status = '-';
+    try {
+      const mod = installer.loadInstaller(tool);
+      const isInst = await mod.isInstalled(context);
+      status = isInst ? 'yes' : 'no';
+    } catch {
+      status = '?';
+    }
+
+    rows.push({
+      Name: tool.name,
+      Description: tool.description,
+      Installed: status,
+    });
+  }
+
+  context.output.out(rows);
+}
+
+module.exports = { meta, run };

package/src/commands/tools/search.js

@@ -0,0 +1,60 @@
+'use strict';
+
+/**
+ * Command: dev tools search <query>
+ *
+ * Searches for tools by name or keyword in the registry.
+ * Matches against tool name and description (case-insensitive).
+ */
+
+/**
+ * @type {{ description: string, arguments: Array, flags: Array }}
+ */
+const meta = {
+  description: 'Search for tools by name or keyword',
+  arguments: [
+    { name: 'query', description: 'Search term (matches name and description)', required: true }
+  ],
+  flags: []
+};
+
+/**
+ * Runs the search command.
+ * @param {{ positional: string[], flags: object }} args - Parsed command arguments.
+ * @param {object} context - The CLI context object.
+ */
+async function run(args, context) {
+  const query = args.positional[0];
+
+  if (!query) {
+    context.errors.throwError(400, 'Missing required argument: query. Usage: dev tools search <query>', 'tools');
+    return;
+  }
+
+  const installer = require('../../lib/installer');
+
+  // Load the registry and search
+  const tools = installer.loadRegistry();
+  const lower = query.toLowerCase();
+
+  const matches = tools.filter(t =>
+    t.name.toLowerCase().includes(lower) ||
+    t.description.toLowerCase().includes(lower)
+  );
+
+  if (matches.length === 0) {
+    context.output.info(`No tools found matching '${query}'.`);
+    return;
+  }
+
+  // Format as table with name, description, and platforms
+  const rows = matches.map(t => ({
+    Name: t.name,
+    Description: t.description,
+    Platforms: t.platforms.join(', '),
+  }));
+
+  context.output.out(rows);
+}
+
+module.exports = { meta, run };

package/src/commands/update.js

@@ -1,142 +1,113 @@
-#!/usr/bin/env node
+'use strict';
 
-/**
- * @fileoverview Update command - Update this package to the latest version.
- * Queries the NPM registry and installs the latest version globally.
- */
+const shell = require('../lib/shell');
 
-const { Command } = require('commander');
-const { execSync, spawn } = require('child_process');
-const pkg = require('../../package.json');
+const meta = {
+  description: 'Self-update to the latest published version.',
+  arguments: [],
+  flags: [
+    { name: 'check', description: 'Check for updates without installing' },
+  ],
+};
 
 /**
- * The name of this package on NPM
+ * Get the current installed version from package.json.
+ * @returns {string}
  */
-const PACKAGE_NAME = pkg.name;
+function getCurrentVersion() {
+  const pkg = require('../../package.json');
+  return 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
+ * Get the latest version from the npm registry.
+ * @returns {Promise<string|null>}
  */
-function getLatestVersion() {
-  try {
-    const result = execSync(`npm view ${PACKAGE_NAME} version`, {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-    return result.trim();
-  } catch {
-    return null;
-  }
+async function getLatestVersion() {
+  const result = await shell.exec('npm view @fredlackey/devutils version');
+  if (result.exitCode !== 0) return null;
+  return result.stdout.trim() || 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
+ * Compare two semver strings. Returns true if latest is newer than current.
+ * @param {string} latest
+ * @param {string} current
+ * @returns {boolean}
  */
-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;
-    }
+function isNewer(latest, current) {
+  const l = latest.split('.').map(Number);
+  const c = current.split('.').map(Number);
+  for (let i = 0; i < Math.max(l.length, c.length); i++) {
+    const lv = l[i] || 0;
+    const cv = c[i] || 0;
+    if (lv > cv) return true;
+    if (lv < cv) return false;
   }
-
   return false;
 }
 
-/**
- * Install the latest version of this package globally
- * @returns {Promise<boolean>} True if installation succeeded
- */
-function installLatestVersion() {
-  return new Promise((resolve) => {
-    console.log(`\nInstalling ${PACKAGE_NAME}@latest globally...`);
-    console.log('─'.repeat(40));
-
-    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const child = spawn(npmCommand, ['install', '-g', `${PACKAGE_NAME}@latest`], {
-      stdio: 'inherit'
-    });
-
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve(true);
-      } else {
-        resolve(false);
-      }
-    });
-
-    child.on('error', () => {
-      resolve(false);
-    });
-  });
-}
-
-/**
- * Check for updates and install if available
- * @param {object} options - Command options
- */
-async function runUpdate(options) {
-  const currentVersion = pkg.version;
-
-  console.log(`\n${pkg.name}`);
-  console.log('─'.repeat(40));
-  console.log(`Current version: ${currentVersion}`);
+async function run(args, context) {
+  if (!shell.commandExists('npm')) {
+    context.errors.throwError(500, 'npm is not available on this system. Install Node.js and npm first.', 'update');
+    return;
+  }
 
-  // Check for updates
-  console.log('\nChecking for updates...');
-  const latestVersion = getLatestVersion();
+  const current = getCurrentVersion();
+  context.output.info(`Current version: ${current}`);
+  context.output.info('Checking for updates...');
 
-  if (!latestVersion) {
-    console.log('Unable to check for updates (NPM registry unreachable)');
-    console.log('');
+  const latest = await getLatestVersion();
+  if (!latest) {
+    context.errors.throwError(500, 'Could not reach the npm registry. Check your network connection.', 'update');
     return;
   }
 
-  console.log(`Latest version:  ${latestVersion}`);
-
-  if (!isNewerVersion(currentVersion, latestVersion)) {
-    console.log('\nYou are already running the latest version.');
-    console.log('');
+  if (!isNewer(latest, current)) {
+    const result = {
+      current,
+      latest,
+      updateAvailable: false,
+      message: `Already on the latest version (${current}).`,
+    };
+    context.output.out(result);
     return;
   }
 
-  console.log(`\nUpdate available: ${currentVersion} -> ${latestVersion}`);
+  // Update available
+  if (args.flags.check) {
+    const result = {
+      current,
+      latest,
+      updateAvailable: true,
+      message: `Update available: ${current} -> ${latest}. Run "dev update" to install.`,
+    };
+    context.output.out(result);
+    return;
+  }
 
   // Perform the update
-  const success = await installLatestVersion();
+  context.output.info(`Updating from ${current} to ${latest}...`);
 
-  if (success) {
-    console.log('─'.repeat(40));
-    console.log(`\nSuccessfully updated to version ${latestVersion}`);
-    console.log('');
-  } else {
-    console.log('─'.repeat(40));
-    console.log('\nUpdate failed. Try running manually:');
-    console.log(`  npm install -g ${PACKAGE_NAME}@latest`);
-    console.log('');
-    process.exit(1);
+  const installResult = await shell.exec('npm install -g @fredlackey/devutils@latest');
+
+  if (installResult.exitCode !== 0) {
+    const msg = installResult.stderr || '';
+    if (msg.includes('EACCES') || msg.includes('permission')) {
+      context.errors.throwError(403, 'Permission denied. Try running with sudo: sudo dev update', 'update');
+      return;
+    }
+    context.errors.throwError(500, `Update failed: ${msg}`, 'update');
+    return;
   }
-}
 
-// Create and configure the command
-const update = new Command('update')
-  .description('Update this package to the latest version')
-  .action(runUpdate);
+  const result = {
+    previous: current,
+    current: latest,
+    updateAvailable: false,
+    message: `Updated to ${latest}. Restart your terminal to use the new version.`,
+  };
+  context.output.out(result);
+}
 
-module.exports = update;
+module.exports = { meta, run };

package/src/commands/util/add.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const meta = {
+  description: 'Register a custom utility by name and source path. Copies the script into ~/.devutils/utils/.',
+  arguments: [
+    { name: 'name', required: true, description: 'Name for the utility (used in dev util run <name>)' },
+    { name: 'path', required: true, description: 'Path to the script file or directory to register' },
+  ],
+  flags: [
+    { name: 'link', description: 'Create a symlink instead of copying (for active development)' },
+  ],
+};
+
+/**
+ * Recursively copy a directory.
+ * @param {string} src - Source directory path.
+ * @param {string} dest - Destination directory path.
+ */
+function copyDirectorySync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectorySync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+async function run(args, context) {
+  const name = args.positional[0];
+  const sourcePath = args.positional[1];
+
+  if (!name || !sourcePath) {
+    context.errors.throwError(400, 'Usage: dev util add <name> <path>', 'util');
+    return;
+  }
+
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+    context.output.error('Utility names must be lowercase letters, numbers, and hyphens only.');
+    context.output.info('Example: my-script, git-helper, deploy-2');
+    return;
+  }
+
+  // Check for name conflicts with 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 overridden.`);
+    return;
+  }
+
+  const customDir = path.join(os.homedir(), '.devutils', 'utils');
+  const existingFolder = path.join(customDir, name);
+  const existingFile = path.join(customDir, name + '.js');
+  if (fs.existsSync(existingFolder) || fs.existsSync(existingFile)) {
+    context.output.error(`A custom utility named "${name}" already exists.`);
+    context.output.info('Remove it first with: dev util remove ' + name);
+    return;
+  }
+
+  // Validate the source path
+  const resolvedSource = path.resolve(sourcePath);
+  if (!fs.existsSync(resolvedSource)) {
+    context.output.error(`Source path not found: ${resolvedSource}`);
+    return;
+  }
+
+  const stat = fs.statSync(resolvedSource);
+  let entryPoint;
+
+  if (stat.isDirectory()) {
+    entryPoint = path.join(resolvedSource, 'index.js');
+    if (!fs.existsSync(entryPoint)) {
+      context.output.error('Directory does not contain an index.js file.');
+      return;
+    }
+  } else if (stat.isFile() && resolvedSource.endsWith('.js')) {
+    entryPoint = resolvedSource;
+  } else {
+    context.output.error('Source must be a .js file or a directory containing index.js.');
+    return;
+  }
+
+  // Verify it exports a run function
+  try {
+    const mod = require(entryPoint);
+    if (typeof mod.run !== 'function') {
+      context.output.error('The source file must export a run() function.');
+      return;
+    }
+  } catch (err) {
+    context.output.error(`Failed to load source file: ${err.message}`);
+    return;
+  }
+
+  // Copy or link the utility
+  fs.mkdirSync(customDir, { recursive: true });
+
+  if (args.flags.link) {
+    const linkTarget = stat.isDirectory()
+      ? path.join(customDir, name)
+      : path.join(customDir, name + '.js');
+    fs.symlinkSync(resolvedSource, linkTarget);
+  } else {
+    if (stat.isDirectory()) {
+      copyDirectorySync(resolvedSource, path.join(customDir, name));
+    } else {
+      fs.copyFileSync(resolvedSource, path.join(customDir, name + '.js'));
+    }
+  }
+
+  // Update the custom registry
+  const registryPath = path.join(customDir, 'registry.json');
+  let registry = { utilities: [] };
+  if (fs.existsSync(registryPath)) {
+    try {
+      registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    } catch {
+      registry = { utilities: [] };
+    }
+  }
+
+  const mod = require(entryPoint);
+  const utilMeta = mod.meta || {};
+
+  registry.utilities.push({
+    name: name,
+    description: utilMeta.description || '',
+    type: 'custom',
+    platforms: utilMeta.platforms || [],
+    arguments: utilMeta.arguments || [],
+    flags: utilMeta.flags || [],
+    source: resolvedSource,
+    linked: !!args.flags.link,
+  });
+
+  fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n');
+
+  context.output.info(`Utility "${name}" registered successfully.`);
+  context.output.info(`Run it with: dev util run ${name}`);
+}
+
+module.exports = { meta, run };

package/src/commands/util/index.js

@@ -0,0 +1,15 @@
+/**
+ * Util service registration.
+ * Complex utility functions (platform-aware).
+ */
+module.exports = {
+  name: 'util',
+  description: 'Complex utility functions (platform-aware)',
+  commands: {
+    run:    () => require('./run'),
+    list:   () => require('./list'),
+    show:   () => require('./show'),
+    add:    () => require('./add'),
+    remove: () => require('./remove'),
+  }
+};

package/src/commands/util/list.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const meta = {
+  description: 'List available utilities. Use flags to filter by source.',
+  arguments: [],
+  flags: [
+    { name: 'built-in', description: 'Show only built-in utilities' },
+    { name: 'custom', description: 'Show only user-added utilities' },
+  ],
+};
+
+/**
+ * Load custom utilities from ~/.devutils/utils/.
+ * Checks for a registry.json first; falls back to scanning directories.
+ *
+ * @returns {Array<object>} Array of utility metadata objects.
+ */
+function loadCustomUtilities() {
+  const customDir = path.join(os.homedir(), '.devutils', 'utils');
+  if (!fs.existsSync(customDir)) {
+    return [];
+  }
+
+  const registryPath = path.join(customDir, 'registry.json');
+  if (fs.existsSync(registryPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+      return (data.utilities || []).map(u => ({ ...u, type: 'custom' }));
+    } catch {
+      // Fall through to directory scan
+    }
+  }
+
+  // Fallback: scan directories for index.js with meta exports
+  const entries = fs.readdirSync(customDir, { withFileTypes: true });
+  const utilities = [];
+
+  for (const entry of entries) {
+    if (entry.name === 'registry.json') continue;
+
+    let indexPath;
+    if (entry.isDirectory()) {
+      indexPath = path.join(customDir, entry.name, 'index.js');
+    } else if (entry.isFile() && entry.name.endsWith('.js')) {
+      indexPath = path.join(customDir, entry.name);
+    }
+
+    if (indexPath && fs.existsSync(indexPath)) {
+      try {
+        const mod = require(indexPath);
+        if (mod.meta) {
+          utilities.push({
+            name: mod.meta.name || entry.name.replace(/\.js$/, ''),
+            description: mod.meta.description || '',
+            type: 'custom',
+          });
+        }
+      } catch {
+        // Skip utilities that fail to load
+      }
+    }
+  }
+
+  return utilities;
+}
+
+async function run(args, context) {
+  const builtInRegistry = require('../../utils/registry.json');
+  const results = [];
+
+  if (!args.flags.custom) {
+    for (const util of builtInRegistry.utilities || []) {
+      results.push({ Name: util.name, Description: util.description, Type: 'built-in' });
+    }
+  }
+
+  if (!args.flags['built-in']) {
+    const custom = loadCustomUtilities();
+    for (const util of custom) {
+      results.push({ Name: util.name, Description: util.description || '', Type: 'custom' });
+    }
+  }
+
+  if (results.length === 0) {
+    context.output.info('No utilities found.');
+    return;
+  }
+
+  context.output.out(results);
+  context.output.info(`\n${results.length} ${results.length === 1 ? 'utility' : 'utilities'} available.`);
+}
+
+module.exports = { meta, run };