@fredlackey/devutils 0.0.18 → 0.1.0

package/src/commands/status.js

@@ -1,223 +1,276 @@
-#!/usr/bin/env node
+'use strict';
 
 /**
- * @fileoverview Status command - Display current configuration and environment health.
+ * status command.
+ * An overall health check that shows the current state of the DevUtils
+ * installation in a single-screen dashboard. Checks config, machine
+ * profile, auth services, aliases, API plugins, and sync status.
+ *
+ * This command is read-only and never modifies any files. It handles
+ * missing files gracefully, showing helpful placeholder messages
+ * instead of crashing.
  */
 
-const { Command } = require('commander');
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
+const os = require('os');
 
-const CONFIG_FILE = path.join(process.env.HOME || process.env.USERPROFILE, '.devutils');
+const meta = {
+  description: 'Overall health check',
+  arguments: [],
+  flags: []
+};
 
 /**
- * Load existing configuration
- * @returns {object|null}
+ * Checks the config.json status. Reports whether the file exists
+ * and whether it contains valid JSON.
+ *
+ * @param {object} config - The context.config module.
+ * @returns {{ exists: boolean, valid: boolean }}
  */
-function loadConfig() {
-  try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      const content = fs.readFileSync(CONFIG_FILE, 'utf8');
-      return JSON.parse(content);
-    }
-  } catch {
-    return null;
+function checkConfig(config) {
+  if (!config.exists('config.json')) {
+    return { exists: false, valid: false };
   }
-  return null;
+  const data = config.read('config.json');
+  if (data === null) {
+    return { exists: true, valid: false };
+  }
+  return { exists: true, valid: true };
 }
 
 /**
- * Check if current directory is inside a git repository
- * @returns {string|null} Path to git root or null
+ * Checks the machine profile. Reads machines/current.json and pulls
+ * out key fields like type, arch, hostname, and packageManager.
+ *
+ * @param {object} config - The context.config module.
+ * @returns {{ detected: boolean, type?: string, arch?: string, hostname?: string, packageManager?: string }}
  */
-function getGitRoot() {
-  try {
-    const result = execSync('git rev-parse --show-toplevel', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-    return result.trim();
-  } catch {
-    return null;
+function checkMachine(config) {
+  const profile = config.read('machines/current.json');
+  if (!profile) {
+    return { detected: false };
   }
+
+  return {
+    detected: true,
+    type: profile.os ? profile.os.type : (profile.type || 'unknown'),
+    arch: profile.arch || 'unknown',
+    hostname: profile.hostname || 'unknown',
+    packageManager: profile.packageManagers
+      ? profile.packageManagers[0] || null
+      : (profile.packageManager || null),
+  };
 }
 
 /**
- * Get current git branch
- * @returns {string|null}
+ * Checks the auth directory for connected services.
+ * Each JSON file (excluding subdirectories) represents a connected service.
+ *
+ * @param {object} config - The context.config module.
+ * @returns {{ services: string[], count: number }}
  */
-function getGitBranch() {
+function checkAuth(config) {
+  const authDir = config.getPath('auth');
+  if (!fs.existsSync(authDir)) {
+    return { services: [], count: 0 };
+  }
+
   try {
-    const result = execSync('git branch --show-current', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-    return result.trim();
+    const entries = fs.readdirSync(authDir);
+    const services = entries
+      .filter(entry => {
+        const fullPath = path.join(authDir, entry);
+        return fs.statSync(fullPath).isFile() && entry.endsWith('.json');
+      })
+      .map(file => path.basename(file, '.json'));
+
+    return { services, count: services.length };
   } catch {
-    return null;
+    return { services: [], count: 0 };
   }
 }
 
 /**
- * Get Node.js version
- * @returns {string|null}
+ * Checks the aliases.json file for registered aliases.
+ *
+ * @param {object} config - The context.config module.
+ * @returns {{ count: number }}
  */
-function getNodeVersion() {
-  try {
-    return process.version;
-  } catch {
-    return null;
+function checkAliases(config) {
+  const data = config.read('aliases.json');
+  if (!data) {
+    return { count: 0 };
   }
+
+  // Handle both array and object formats
+  if (Array.isArray(data)) {
+    return { count: data.length };
+  }
+  return { count: Object.keys(data).length };
 }
 
 /**
- * Get npm version
- * @returns {string|null}
+ * Checks the plugins.json file for installed API plugins.
+ *
+ * @param {object} config - The context.config module.
+ * @returns {{ count: number, plugins: string[] }}
  */
-function getNpmVersion() {
-  try {
-    return execSync('npm --version', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-  } catch {
-    return null;
+function checkPlugins(config) {
+  const data = config.read('plugins.json');
+  if (!data) {
+    return { count: 0, plugins: [] };
+  }
+
+  // Handle both array and object formats
+  if (Array.isArray(data)) {
+    return { count: data.length, plugins: data };
+  }
+  const plugins = Object.keys(data);
+  return { count: plugins.length, plugins };
+}
+
+/**
+ * Checks the sync.json file for the last backup timestamp.
+ *
+ * @param {object} config - The context.config module.
+ * @returns {{ lastBackup: string|null }}
+ */
+function checkSync(config) {
+  const data = config.read('sync.json');
+  if (!data || !data.lastBackup) {
+    return { lastBackup: null };
+  }
+  return { lastBackup: data.lastBackup };
+}
+
+/**
+ * Formats a human-readable summary line for the config section.
+ *
+ * @param {{ exists: boolean, valid: boolean }} configStatus - The config check result.
+ * @returns {string}
+ */
+function formatConfig(configStatus) {
+  if (!configStatus.exists) {
+    return 'Not found. Run \'dev config init\' to get started.';
+  }
+  if (!configStatus.valid) {
+    return 'Invalid JSON. Check ~/.devutils/config.json for syntax errors.';
+  }
+  return 'OK';
+}
+
+/**
+ * Formats a human-readable summary line for the machine section.
+ *
+ * @param {{ detected: boolean, type?: string, arch?: string, packageManager?: string }} machineStatus - The machine check result.
+ * @returns {string}
+ */
+function formatMachine(machineStatus) {
+  if (!machineStatus.detected) {
+    return 'Not detected. Run \'dev machine detect\' to set up.';
   }
+  const pm = machineStatus.packageManager ? ` (${machineStatus.packageManager})` : '';
+  return `${machineStatus.type} ${machineStatus.arch}${pm}`;
 }
 
 /**
- * Detect operating system
+ * Formats a human-readable summary line for the auth section.
+ *
+ * @param {{ services: string[], count: number }} authStatus - The auth check result.
  * @returns {string}
  */
-function getOS() {
-  switch (process.platform) {
-    case 'darwin':
-      return 'macOS';
-    case 'win32':
-      return 'Windows';
-    case 'linux':
-      return 'Linux';
-    default:
-      return process.platform;
+function formatAuth(authStatus) {
+  if (authStatus.count === 0) {
+    return 'No services connected.';
   }
+  return `${authStatus.count} services (${authStatus.services.join(', ')})`;
 }
 
 /**
- * Check if a command exists
- * @param {string} cmd - Command to check
- * @returns {boolean}
+ * Formats a human-readable summary line for the aliases section.
+ *
+ * @param {{ count: number }} aliasStatus - The alias check result.
+ * @returns {string}
  */
-function commandExists(cmd) {
+function formatAliases(aliasStatus) {
+  if (aliasStatus.count === 0) {
+    return 'None registered.';
+  }
+  return `${aliasStatus.count} registered`;
+}
+
+/**
+ * Formats a human-readable summary line for the plugins section.
+ *
+ * @param {{ count: number, plugins: string[] }} pluginStatus - The plugin check result.
+ * @returns {string}
+ */
+function formatPlugins(pluginStatus) {
+  if (pluginStatus.count === 0) {
+    return 'None installed.';
+  }
+  return `${pluginStatus.count} installed (${pluginStatus.plugins.join(', ')})`;
+}
+
+/**
+ * Formats a human-readable summary line for the sync section.
+ *
+ * @param {{ lastBackup: string|null }} syncStatus - The sync check result.
+ * @returns {string}
+ */
+function formatSync(syncStatus) {
+  if (!syncStatus.lastBackup) {
+    return 'Never.';
+  }
+  // Format the ISO timestamp into something more readable
   try {
-    const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
-    execSync(checkCmd, { stdio: ['pipe', 'pipe', 'pipe'] });
-    return true;
+    const date = new Date(syncStatus.lastBackup);
+    return date.toLocaleString();
   } catch {
-    return false;
+    return syncStatus.lastBackup;
   }
 }
 
 /**
- * Display status information
- * @param {object} options - Command options
+ * Runs the status health check. Gathers information from config files,
+ * machine profile, auth directory, aliases, plugins, and sync state.
+ * Outputs a compact summary for humans or a structured object for JSON.
+ *
+ * @param {object} args - Parsed command arguments (none expected).
+ * @param {object} context - The CLI context object with config, platform, shell, output, flags.
  */
-function runStatus(options) {
-  const config = loadConfig();
-  const warnings = [];
-
-  console.log('\n=== DevUtils CLI Status ===\n');
-
-  // Configuration Status
-  console.log('Configuration:');
-  console.log('─'.repeat(40));
-
-  if (config) {
-    console.log(`  File:    ${CONFIG_FILE}`);
-    console.log('  Status:  Valid');
-
-    if (config.user) {
-      console.log(`  User:    ${config.user.name} <${config.user.email}>`);
-    }
-
-    if (config.updated) {
-      console.log(`  Updated: ${new Date(config.updated).toLocaleString()}`);
-    }
-
-    // Check for issues
-    if (!config.user?.name || !config.user?.email) {
-      warnings.push('User name or email not configured');
-    }
-  } else {
-    console.log(`  File:   ${CONFIG_FILE}`);
-    console.log('  Status: Not found');
-    warnings.push(`Configuration file not found. Run 'dev configure' to create it.`);
-  }
-
-  // Environment
-  console.log('\nEnvironment:');
-  console.log('─'.repeat(40));
-  console.log(`  OS:      ${getOS()}`);
-  console.log(`  Node:    ${getNodeVersion() || 'Not found'}`);
-  console.log(`  npm:     ${getNpmVersion() || 'Not found'}`);
-  console.log(`  CWD:     ${process.cwd()}`);
-
-  // Git Repository
-  const gitRoot = getGitRoot();
-  console.log('\nGit Repository:');
-  console.log('─'.repeat(40));
-
-  if (gitRoot) {
-    console.log(`  Root:    ${gitRoot}`);
-    console.log(`  Branch:  ${getGitBranch() || 'Unknown'}`);
-  } else {
-    console.log('  Status:  Not in a git repository');
-  }
-
-  // Available Tools
-  console.log('\nAvailable Tools:');
-  console.log('─'.repeat(40));
-
-  const tools = [
-    { name: 'git', label: 'Git' },
-    { name: 'docker', label: 'Docker' },
-    { name: 'code', label: 'VS Code' },
-    { name: 'brew', label: 'Homebrew' },
-    { name: 'choco', label: 'Chocolatey' },
-    { name: 'winget', label: 'winget' }
-  ];
-
-  for (const tool of tools) {
-    const exists = commandExists(tool.name);
-    const status = exists ? 'Installed' : 'Not found';
-    console.log(`  ${tool.label.padEnd(12)} ${status}`);
-  }
-
-  // Identities
-  if (config?.identities && Object.keys(config.identities).length > 0) {
-    console.log('\nIdentities:');
-    console.log('─'.repeat(40));
-    for (const [name, identity] of Object.entries(config.identities)) {
-      console.log(`  ${name}: ${identity.email || identity.name || '(incomplete)'}`);
-    }
-  }
-
-  // Warnings
-  if (warnings.length > 0) {
-    console.log('\nWarnings:');
-    console.log('─'.repeat(40));
-    for (const warning of warnings) {
-      console.log(`  ! ${warning}`);
-    }
-  }
-
-  console.log('');
-}
+async function run(args, context) {
+  const configStatus = checkConfig(context.config);
+  const machineStatus = checkMachine(context.config);
+  const authStatus = checkAuth(context.config);
+  const aliasStatus = checkAliases(context.config);
+  const pluginStatus = checkPlugins(context.config);
+  const syncStatus = checkSync(context.config);
+
+  const result = {
+    config: configStatus,
+    machine: machineStatus,
+    auth: authStatus,
+    aliases: aliasStatus,
+    plugins: pluginStatus,
+    sync: syncStatus,
+  };
 
-// Create and configure the command
-const status = new Command('status')
-  .description('Display current configuration and environment health')
-  .option('--verbose', 'Show detailed information')
-  .action(runStatus);
+  if (context.flags.format === 'json') {
+    context.output.out(result);
+    return;
+  }
+
+  // Human-friendly output
+  context.output.info('DevUtils Status');
+  context.output.info('---------------');
+  context.output.info(`Config:      ${formatConfig(configStatus)}`);
+  context.output.info(`Machine:     ${formatMachine(machineStatus)}`);
+  context.output.info(`Auth:        ${formatAuth(authStatus)}`);
+  context.output.info(`Aliases:     ${formatAliases(aliasStatus)}`);
+  context.output.info(`API Plugins: ${formatPlugins(pluginStatus)}`);
+  context.output.info(`Last Sync:   ${formatSync(syncStatus)}`);
+}
 
-module.exports = status;
+module.exports = { meta, run };

package/src/commands/tools/check.js

@@ -0,0 +1,79 @@
+'use strict';
+
+/**
+ * Command: dev tools check <tool-name>
+ *
+ * Checks if a tool is installed and shows its version.
+ */
+
+/**
+ * @type {{ description: string, arguments: Array, flags: Array }}
+ */
+const meta = {
+  description: 'Check if a tool is installed and show its version',
+  arguments: [
+    { name: 'tool', description: 'Name of the tool to check', required: true }
+  ],
+  flags: []
+};
+
+/**
+ * Runs the check command.
+ * @param {{ positional: string[], flags: object }} args - Parsed command arguments.
+ * @param {object} context - The CLI context object.
+ */
+async function run(args, context) {
+  const toolName = args.positional[0];
+
+  if (!toolName) {
+    context.errors.throwError(400, 'Missing required argument: tool. Usage: dev tools check <tool-name>', 'tools');
+    return;
+  }
+
+  const installer = require('../../lib/installer');
+
+  // Look up the tool in the registry
+  const tool = installer.findTool(toolName);
+  if (!tool) {
+    context.output.error(`Tool '${toolName}' not found in registry. Run "dev tools search ${toolName}" to search.`);
+    return;
+  }
+
+  try {
+    // Load the installer and check if the tool is installed
+    const mod = installer.loadInstaller(tool);
+    const installed = await mod.isInstalled(context);
+
+    if (installed) {
+      // Try to get the version
+      let version = 'version unknown';
+      if (typeof mod.getVersion === 'function') {
+        const ver = await mod.getVersion(context);
+        if (ver) {
+          version = `version ${ver}`;
+        }
+      } else {
+        // Fall back to --version
+        try {
+          const result = await context.shell.exec(`${tool.name} --version`);
+          if (result.exitCode === 0 && result.stdout) {
+            const match = result.stdout.trim().match(/(\d+\.\d+[\.\d]*)/);
+            if (match) {
+              version = `version ${match[1]}`;
+            }
+          }
+        } catch {
+          // version remains "version unknown"
+        }
+      }
+
+      context.output.out({ name: tool.name, installed: true, version });
+    } else {
+      context.output.out({ name: tool.name, installed: false, version: null });
+    }
+  } catch (err) {
+    context.output.error(err.message);
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/tools/index.js

@@ -0,0 +1,14 @@
+/**
+ * Tools service registration.
+ * Tool installation and management.
+ */
+module.exports = {
+  name: 'tools',
+  description: 'Tool installation and management',
+  commands: {
+    install: () => require('./install'),
+    check:   () => require('./check'),
+    list:    () => require('./list'),
+    search:  () => require('./search'),
+  }
+};

package/src/commands/tools/install.js

@@ -0,0 +1,110 @@
+'use strict';
+
+/**
+ * Command: dev tools install <tool-name>
+ *
+ * Installs a development tool using the platform-appropriate method.
+ * Resolves and installs dependencies automatically.
+ */
+
+/**
+ * @type {{ description: string, arguments: Array, flags: Array }}
+ */
+const meta = {
+  description: 'Install a development tool',
+  arguments: [
+    { name: 'tool', description: 'Name of the tool to install', required: true }
+  ],
+  flags: [
+    { name: '--dry-run', description: 'Show what would be installed without doing it' },
+    { name: '--skip-deps', description: 'Skip dependency installation' }
+  ]
+};
+
+/**
+ * Runs the install command.
+ * @param {{ positional: string[], flags: object }} args - Parsed command arguments.
+ * @param {object} context - The CLI context object.
+ */
+async function run(args, context) {
+  const toolName = args.positional[0];
+
+  if (!toolName) {
+    context.errors.throwError(400, 'Missing required argument: tool. Usage: dev tools install <tool-name>', 'tools');
+    return;
+  }
+
+  const installer = require('../../lib/installer');
+
+  // Look up the tool in the registry
+  const tool = installer.findTool(toolName);
+  if (!tool) {
+    context.output.error(`Tool '${toolName}' not found in registry. Run "dev tools search ${toolName}" to search.`);
+    return;
+  }
+
+  // Check platform support
+  const platformType = context.platform.detect().type;
+  if (!tool.platforms.includes(platformType)) {
+    context.output.error(
+      `Tool '${tool.name}' is not supported on ${platformType}. ` +
+      `Supported platforms: ${tool.platforms.join(', ')}`
+    );
+    return;
+  }
+
+  // Dry run: show what would be installed without doing it
+  if (context.flags.dryRun || args.flags['dry-run']) {
+    try {
+      const chain = installer.resolveDependencies(tool.name);
+
+      // Check which tools are already installed
+      const statuses = [];
+      for (const name of chain) {
+        const isAlready = await installer.checkInstalled(name, context);
+        statuses.push({ name, installed: isAlready });
+      }
+
+      const needsInstall = statuses.filter(s => !s.installed);
+      const alreadyInstalled = statuses.filter(s => s.installed);
+
+      if (needsInstall.length === 0) {
+        context.output.info(`${tool.name} is already installed (and all dependencies).`);
+      } else {
+        context.output.info('Would install (in order):');
+        for (const s of needsInstall) {
+          context.output.info(`  - ${s.name}`);
+        }
+        if (alreadyInstalled.length > 0) {
+          context.output.info('Already installed:');
+          for (const s of alreadyInstalled) {
+            context.output.info(`  - ${s.name}`);
+          }
+        }
+      }
+    } catch (err) {
+      context.output.error(err.message);
+    }
+    return;
+  }
+
+  // Actually install
+  try {
+    const result = await installer.installTool(tool.name, context);
+
+    if (result.alreadyInstalled) {
+      context.output.info(`${tool.name} is already installed.`);
+    } else {
+      if (result.dependenciesInstalled.length > 0) {
+        context.output.info(`Dependencies installed: ${result.dependenciesInstalled.join(', ')}`);
+      }
+      if (result.installed) {
+        context.output.info(`${tool.name} installed successfully.`);
+      }
+    }
+  } catch (err) {
+    context.output.error(err.message);
+  }
+}
+
+module.exports = { meta, run };