node-power-user 1.0.2 → 1.0.6

package/bin/npu

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const argv = require('yargs').argv;
-const Main = new (require('../dist/index.js'))(argv);
+const cli = new (require('../dist/cli.js'))(argv);
 (async function() {
   'use strict';
-  await Main.process(argv);
+  await cli.process(argv);
 }());

package/dist/cli.js

@@ -0,0 +1,64 @@
+// Libraries
+const path = require('path');
+const jetpack = require('fs-jetpack');
+
+// Command Aliases
+const DEFAULT = 'version';
+const ALIASES = {
+  bump: ['-b', '--bump'],
+  clean: ['-c', '--clean'],
+  global: ['-g', '--global'],
+  outdated: ['-o', 'out', '--outdated'],
+  packages: ['-p', 'pack', '--packages'],
+  version: ['-v', '--version'],
+  sync: ['-s', '--sync'],
+};
+
+// Function to resolve command name from aliases
+function resolveCommand(command) {
+    console.log('---1 command', command);
+  for (const [key, aliases] of Object.entries(ALIASES)) {
+    console.log('---2 key, aliases', key, aliases);
+
+    if (command === key || aliases.includes(command)) {
+    console.log('---3');
+      return key;
+    }
+  }
+
+  // Default to original command if no alias is found
+    console.log('---4');
+  return command;
+}
+
+// Main Function
+function Main() {}
+
+Main.prototype.process = async function (options) {
+  // Determine the command (use default if not provided)
+  console.log('---options', options);
+
+  const inputCommand = options._[0] || DEFAULT;
+  const command = resolveCommand(inputCommand);
+
+  try {
+    // Get the command file path
+    const commandFile = path.join(__dirname, 'commands', `${command}.js`);
+
+    // Check if the command file exists
+    if (!jetpack.exists(commandFile)) {
+      throw new Error(`Error: Command "${command}" not found.`);
+    }
+
+    // Execute the command
+    const Command = require(commandFile);
+    await Command(options);
+  } catch (e) {
+    console.error(`Error executing command "${command}": ${e.message}`);
+
+    // Exit with error
+    throw e;
+  }
+};
+
+module.exports = Main;

package/dist/commands/bump.js

@@ -0,0 +1,40 @@
+// Libraries
+const logger = new (require('../lib/logger'))('node-power-user');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+const version = require('wonderful-version');
+
+// Load package
+const package = jetpack.read(path.join(__dirname, '../../', 'package.json'), 'json');
+const project = jetpack.read(path.join(process.cwd(), 'package.json'), 'json');
+
+// Module
+module.exports = async function (options) {
+  // Determine bump level
+  const ver = project.version;
+  let newVer;
+
+  // Log
+  // logger.log(`Current version: ${ver}`, options);
+
+  // Bump
+  if (options.major || options._.includes('major')) {
+    newVer = version.increment(ver, 'major');
+  } else if (options.minor || options._.includes('minor')) {
+    newVer = version.increment(ver, 'minor');
+  } else {
+    newVer = version.increment(ver, 'patch');
+  }
+
+  // Update package.json
+  project.version = newVer;
+
+  // Write package.json
+  jetpack.write(path.join(process.cwd(), 'package.json'), project);
+
+  // Log
+  logger.log(`Bumped version: ${logger.format.bold(ver)} ==> ${logger.format.bold(newVer)}`);
+
+  // Return new version
+  return newVer;
+};

package/dist/commands/clean.js

@@ -0,0 +1,33 @@
+// Libraries
+const logger = new (require('../lib/logger'))('node-power-user');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+const { execute } = require('node-powertools');
+
+// Load package.json files
+const package = jetpack.read(path.join(__dirname, '../../', 'package.json'), 'json');
+const project = jetpack.read(path.join(process.cwd(), 'package.json'), 'json');
+
+// Module
+module.exports = async function (options) {
+  // Define cleanup command
+  const command = `rm -rf node_modules && rm -rf package-lock.json && npm cache clean --force`;
+
+  // Log initial state
+  logger.log(`Cleaning project: ${logger.format.bold(project.name)} (v${project.version})`);
+
+  try {
+    // Run cleanup commands
+    await execute(command, { log: true });
+
+    // Log success
+    logger.log(logger.format.green('Cleanup completed successfully!'));
+
+    return true;
+  } catch (e) {
+    // Log failure
+    logger.error(`Cleanup failed`, e.stack);
+
+    return false;
+  }
+};

package/dist/commands/global.js

@@ -0,0 +1,99 @@
+// Libraries
+const logger = new (require('../lib/logger'))('node-power-user');
+const path = require('path');
+const os = require('os');
+const jetpack = require('fs-jetpack');
+const version = require('wonderful-version');
+const { table } = require('table');
+const ProgressBar = require('cli-progress');
+const Npm = require('npm-api');
+const chalk = require('chalk');
+
+const npm = new Npm();
+
+// Module
+module.exports = async function (options) {
+  // Define global modules path
+  const parentPath = `/Users/${os.userInfo().username}/.nvm/versions/node`;
+  const versions = jetpack.list(parentPath) || [];
+  const response = {};
+
+  // Log start
+  logger.log(`Checking global modules for ${logger.format.bold(versions.length)} Node.js versions...`);
+
+  // Loop through Node.js versions
+  for (const ver of versions) {
+    try {
+      // Quick check if ver starts with a dot
+      if (ver.startsWith('.')) {
+        continue;
+      }
+
+      // Clean
+      const cleaned = version.clean(ver);
+      const libPath = path.resolve(parentPath, `v${cleaned}`, 'lib', 'node_modules');
+      const modules = jetpack.list(libPath) || [];
+
+      // Log version being checked
+      logger.log(`Checking global modules for Node v${logger.format.bold(cleaned)}...`);
+
+      // Skip if no global modules found
+      if (!modules.length) {
+        logger.warn(`No global modules found for Node v${logger.format.bold(cleaned)}.`);
+        continue;
+      }
+
+      // Initialize progress bar
+      const progress = new ProgressBar.SingleBar({}, ProgressBar.Presets.shades_classic);
+      progress.start(modules.length, 0);
+
+      // Initialize data
+      response[cleaned] = {};
+      const data = [['Name', 'Package', 'Latest']];
+
+      // Loop through modules
+      for (const mod of modules) {
+        const packagePath = path.resolve(libPath, mod, 'package.json');
+        try {
+          const packageJson = require(packagePath);
+          const packageVersion = packageJson.version;
+
+          // Fetch the latest version from npm
+          let latestVersion = await npm.repo(mod).package().then(pkg => pkg.version).catch(() => '?');
+
+          // Determine version color-coding
+          const isLatest = packageVersion === latestVersion;
+          const verb = isLatest ? 'green' : 'red';
+
+          // Add to response and table data
+          data.push([
+            mod,
+            packageVersion,
+            chalk[verb](latestVersion)
+          ]);
+          response[cleaned][mod] = {
+            version: packageVersion,
+            latest: latestVersion
+          };
+        } catch (e) {}
+
+        progress.increment();
+      }
+
+      // Stop progress bar
+      progress.stop();
+
+      // Display results
+      console.log(table(data));
+
+    } catch (e) {
+      logger.error(`Error processing Node v${ver}:`, e.stack);
+    }
+  }
+
+  // Log completion
+  logger.log(logger.format.green('Global module check completed successfully!'));
+
+  // Return response
+  return response;
+};

package/dist/commands/outdated.js

@@ -0,0 +1,100 @@
+// Libraries
+const logger = new (require('../lib/logger'))('node-power-user');
+const chalk = require('chalk');
+const { table } = require('table');
+const ProgressBar = require('cli-progress');
+const Npm = require('npm-api');
+const version = require('wonderful-version');
+const jetpack = require('fs-jetpack');
+const path = require('path');
+
+const npm = new Npm();
+
+// Load package.json
+const projectPath = process.cwd();
+const projectJson = jetpack.read(path.join(projectPath, 'package.json'), 'json') || {};
+
+// Module
+module.exports = async function (options) {
+  // Combine all dependencies
+  const allDependencies = Object.assign(
+    {},
+    projectJson.dependencies,
+    projectJson.devDependencies,
+    projectJson.peerDependencies
+  );
+
+  // Check if there are any dependencies
+  if (Object.keys(allDependencies).length === 0) {
+    logger.warn('No dependencies found in package.json.');
+    return {};
+  }
+
+  // Log start
+  logger.log(`Checking outdated dependencies for ${logger.format.bold(projectJson.name || 'Unknown Project')}...`);
+
+  // Initialize data table
+  const data = [['Name', 'Package', 'Installed', 'Latest']];
+  const progress = new ProgressBar.SingleBar({}, ProgressBar.Presets.shades_classic);
+  progress.start(Object.keys(allDependencies).length, 0);
+
+  const response = {};
+
+  // Loop through dependencies
+  for (const dep of Object.keys(allDependencies)) {
+    try {
+      progress.increment();
+
+      // Get version info
+      const packageVersion = version.clean(allDependencies[dep]); // Version from package.json
+      const installedPackagePath = path.join(projectPath, 'node_modules', dep, 'package.json');
+
+      let installedVersion = '?';
+      if (jetpack.exists(installedPackagePath)) {
+        const installedJson = jetpack.read(installedPackagePath, 'json');
+        installedVersion = installedJson?.version ? version.clean(installedJson.version) : '?';
+      }
+
+      // Get latest published version
+      const latestVersion = await npm.repo(dep).package().then(pkg => version.clean(pkg.version)).catch(() => '?');
+
+      // Check version statuses
+      const isInstalledCurrent = version.is(installedVersion, '==', packageVersion);
+      const isUpToDate = version.is(packageVersion, '>=', latestVersion);
+
+      // Format version colors
+      const installedColor = isInstalledCurrent ? 'green' : 'yellow';
+      const latestColor = isUpToDate ? 'green' : 'red';
+
+      // Store response data
+      response[dep] = {
+        package: packageVersion,
+        installed: installedVersion,
+        latest: latestVersion,
+        isInstalledCurrent,
+        isUpToDate
+      };
+
+      // Add row to table
+      data.push([
+        dep,
+        packageVersion,
+        chalk[installedColor](installedVersion),
+        chalk[latestColor](latestVersion)
+      ]);
+    } catch (e) {
+      logger.error(`Error checking ${dep}: ${e.message}`);
+    }
+  }
+
+  // Stop progress bar
+  progress.stop();
+
+  // Display table
+  console.log(table(data));
+
+  // Log completion
+  logger.log(logger.format.green('Outdated package check completed successfully!'));
+
+  return response;
+};

package/dist/commands/packages.js

@@ -0,0 +1,58 @@
+// Libraries
+const logger = new (require('../lib/logger'))('node-power-user');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+const chalk = require('chalk');
+const { table } = require('table');
+
+// Load package.json
+const projectPath = process.cwd();
+const projectJson = jetpack.read(path.join(projectPath, 'package.json'), 'json') || {};
+
+// Module
+module.exports = async function (options) {
+  // Log start
+  logger.log(`Listing dependencies for ${logger.format.bold(projectJson.name || 'Unknown Project')} (v${projectJson.version || '0.0.0'})...`);
+
+  // Initialize response
+  const response = {
+    dependencies: {},
+    devDependencies: {},
+    peerDependencies: {}
+  };
+
+  // Initialize table data
+  const data = [['name', 'Version']];
+
+  // Helper function to process dependencies
+  const processDeps = (deps, type, label) => {
+    if (!deps || Object.keys(deps).length === 0) return;
+
+    // Insert a separator row if the table already has data
+    if (data.length > 1) data.push([label, chalk.gray('───────')]);
+
+    Object.entries(deps).forEach(([pkg, version]) => {
+      data.push([pkg, version]);
+      response[type][pkg] = version;
+    });
+  };
+
+  // Process dependencies
+  processDeps(projectJson.dependencies, 'dependencies', 'Dependencies');
+  processDeps(projectJson.devDependencies, 'devDependencies', 'Dev Dependencies');
+  processDeps(projectJson.peerDependencies, 'peerDependencies', 'Peer Dependencies');
+
+  // Check if the table has any data
+  if (data.length === 1) {
+    logger.warn('No dependencies found in package.json.');
+    return response;
+  }
+
+  // Display table
+  console.log(table(data));
+
+  // Log completion
+  logger.log(logger.format.green('Package listing completed successfully!'));
+
+  return response;
+};

package/dist/commands/sync.js

@@ -0,0 +1,64 @@
+// Libraries
+const logger = new (require('../lib/logger'))('node-power-user');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+const { execute } = require('node-powertools');
+const inquirer = require('@inquirer/prompts');
+
+// Load package.json files
+const package = jetpack.read(path.join(__dirname, '../../', 'package.json'), 'json');
+const project = jetpack.read(path.join(process.cwd(), 'package.json'), 'json');
+
+// Module
+module.exports = async function (options) {
+  // Collect answers using the new @inquirer/prompts methods
+  const message = await ask({
+    message: 'Enter a commit message',
+    default: 'Update',
+    value: options.message,
+    multiline: false,
+  });
+
+  // Define cleanup command
+  const command = `git pull && git add . && git commit -m "${message}" && git push origin`;
+
+  // Log initial state
+  logger.log(`Syncing repo...`);
+
+  try {
+    // Run cleanup commands
+    await execute(command, { log: true });
+
+    // Log success
+    logger.log(logger.format.green('Sync completed successfully!'));
+
+    return true;
+  } catch (e) {
+    // Log failure
+    logger.error(`Sync failed`, e.stack);
+
+    return false;
+  }
+};
+
+function ask(options) {
+  options = options || {};
+
+  // If a value is provided, return it
+  if (typeof options.value !== 'undefined') {
+    return options.value;
+  }
+
+  // Check if multuiline is enabled
+  if (options.multiline) {
+    return inquirer.editor({
+      message: options.message,
+      default: options.default,
+    });
+  }
+
+  return inquirer.input({
+    message: options.message,
+    default: options.default,
+  });
+}

package/dist/commands/version.js

@@ -0,0 +1,13 @@
+// Libraries
+const logger = new (require('../lib/logger'))('node-power-user');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+
+// Load package
+const package = jetpack.read(path.join(__dirname, '../../', 'package.json'), 'json');
+const project = jetpack.read(path.join(process.cwd(), 'package.json'), 'json');
+
+module.exports = async function (options) {
+  // Log version
+  console.log(package.version);
+};

package/dist/lib/logger.js

@@ -0,0 +1,56 @@
+// Libraries
+const chalk = require('chalk');
+
+// Logger class
+function Logger(name) {
+  const self = this;
+
+  // Properties
+  self.name = name;
+}
+
+// Loop through log, error, warn, and info and make methods that log to console with the name and time [xx:xx:xx] name: message
+['log', 'error', 'warn', 'info'].forEach((method) => {
+  Logger.prototype[method] = function () {
+    // Get time
+    const time = new Date().toLocaleTimeString('en-US', {
+      hour12: false,
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    });
+
+    // Determine color based on method
+    let color;
+    switch (method) {
+      case 'warn':
+        color = chalk.yellow;
+        break;
+      case 'error':
+        color = chalk.red;
+        break;
+      default:
+        color = (text) => text; // No color
+    }
+
+    // Convert arguments to array and prepend time and name
+    const args = [`[${chalk.magenta(time)}] '${chalk.cyan(this.name)}':`, ...Array.from(arguments).map(arg => {
+      return typeof arg === 'string'
+        ? color(arg)
+        : (
+            arg instanceof Error
+              ? color(arg.stack)
+              : arg
+          );
+    })];
+
+    // Log
+    console[method].apply(console, args);
+  };
+});
+
+// Export chalk as color
+Logger.prototype.format = chalk;
+
+// Export
+module.exports = Logger;

package/package.json

@@ -1,13 +1,8 @@
 {
   "name": "node-power-user",
-  "version": "1.0.2",
+  "version": "1.0.6",
   "description": "Easy tools for every Node.js developer!",
   "main": "dist/index.js",
-  "bin": {
-    "npu": "bin/npu",
-    "node-power-user": "bin/npu",
-    "nodepoweruser": "bin/npu"
-  },
   "scripts": {
     "test": "npm run prepare && ./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
     "start": "npm run prepare && ./bin/npu",
@@ -15,6 +10,11 @@
     "prepare": "node -e \"require('prepare-package')()\"",
     "prepare:watch": "nodemon -w ./src -e '*' --exec 'npm run prepare'"
   },
+  "bin": {
+    "npu": "bin/npu",
+    "node-power-user": "bin/npu",
+    "nodepoweruser": "bin/npu"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/itw-creative-works/node-power-user.git"
@@ -36,22 +36,23 @@
     "replace": {}
   },
   "dependencies": {
+    "@inquirer/prompts": "^7.3.1",
     "chalk": "^4.1.2",
     "cli-progress": "^3.12.0",
     "fs-jetpack": "^4.3.1",
     "inquirer": "^8.2.6",
-    "itwcw-package-analytics": "^1.0.4",
+    "itwcw-package-analytics": "^1.0.6",
     "json5": "^2.2.3",
     "keychain": "^1.5.0",
     "lodash": "^4.17.21",
-    "node-powertools": "^1.4.4",
+    "node-powertools": "^2.1.5",
     "npm-api": "^1.0.1",
-    "semver": "^7.6.2",
-    "table": "^6.8.2",
+    "table": "^6.9.0",
+    "wonderful-version": "^1.3.2",
     "yargs": "^16.2.0"
   },
   "devDependencies": {
     "mocha": "^8.4.0",
-    "prepare-package": "^1.1.12"
+    "prepare-package": "^1.1.14"
   }
-}
+}