jpm-pkg 1.0.3 → 1.0.4

package/bin/jpm.js

@@ -238,7 +238,13 @@ async function main() {
 
     const handler = loader();
     try {
-        await handler(args, flags, command);
+        if (typeof handler === 'function' && handler.prototype instanceof (require('../src/commands/base-command'))) {
+            const instance = new handler(command);
+            await instance.run(args, flags);
+        } else {
+            // Backward compatibility for functional commands
+            await handler(args, flags, command);
+        }
     } catch (err) {
         if (flags.loglevel === 'debug' || flags.loglevel === 'verbose') {
             logger.error(err.stack || err.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jpm-pkg",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Joint Package Manager — Joint, universal, advanced, and blazing fast package manager for Node.js and Bun.",
   "main": "src/index.js",
   "type": "commonjs",

package/src/commands/audit.js

@@ -2,55 +2,84 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const BaseCommand = require('./base-command');
 const auditSec = require('../security/audit');
-const PackageJSON = require('../core/package-json');
 const { Spinner } = require('../utils/progress');
-const logger = require('../utils/logger');
-const config = require('../utils/config');
-
-module.exports = async function auditCmd(args, flags) {
-    const cwd = process.cwd();
-    const nodeModules = path.join(cwd, 'node_modules');
-
-    // Collect all installed packages from node_modules
-    const spinner = new Spinner('Scanning installed packages...').start();
-    const installed = [];
-
-    if (fs.existsSync(nodeModules)) {
-        for (const entry of fs.readdirSync(nodeModules, { withFileTypes: true })) {
-            // Handle scoped packages (@org)
-            if (entry.name.startsWith('@') && entry.isDirectory()) {
-                const scopeDir = path.join(nodeModules, entry.name);
-                for (const scoped of fs.readdirSync(scopeDir, { withFileTypes: true })) {
-                    const pkgJson = path.join(scopeDir, scoped.name, 'package.json');
-                    if (fs.existsSync(pkgJson)) {
-                        try {
-                            const pkg = JSON.parse(fs.readFileSync(pkgJson, 'utf8'));
-                            installed.push({ name: pkg.name, version: pkg.version });
-                        } catch { }
+
+/**
+ * AuditCommand handles the 'jpm audit' and 'jpm scan' commands.
+ * It performs a security and integrity audit of all installed packages.
+ */
+class AuditCommand extends BaseCommand {
+    constructor() {
+        super('audit');
+    }
+
+    /**
+     * Executes the security audit.
+     * 
+     * @param {string[]} args - Optional arguments
+     * @param {Object} flags - CLI flags (e.g., --level)
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const cwd = process.cwd();
+        const nodeModules = path.join(cwd, 'node_modules');
+
+        const spinner = new Spinner('Scanning installed packages...').start();
+        const installed = [];
+
+        if (fs.existsSync(nodeModules)) {
+            for (const entry of fs.readdirSync(nodeModules, { withFileTypes: true })) {
+                // Handle scoped packages (@org/pkg)
+                if (entry.name.startsWith('@') && entry.isDirectory()) {
+                    const scopeDir = path.join(nodeModules, entry.name);
+                    for (const scoped of fs.readdirSync(scopeDir, { withFileTypes: true })) {
+                        const pkgJsonPath = path.join(scopeDir, scoped.name, 'package.json');
+                        this._tryAddPackage(pkgJsonPath, installed);
                     }
-                }
-            } else if (entry.isDirectory() && !entry.name.startsWith('.')) {
-                const pkgJson = path.join(nodeModules, entry.name, 'package.json');
-                if (fs.existsSync(pkgJson)) {
-                    try {
-                        const pkg = JSON.parse(fs.readFileSync(pkgJson, 'utf8'));
-                        installed.push({ name: pkg.name, version: pkg.version });
-                    } catch { }
+                } else if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    const pkgJsonPath = path.join(nodeModules, entry.name, 'package.json');
+                    this._tryAddPackage(pkgJsonPath, installed);
                 }
             }
         }
-    }
 
-    spinner.succeed(`Found ${installed.length} installed packages`);
+        spinner.succeed(`Found ${installed.length} installed packages`);
+
+        const level = flags.level || this.config.auditLevel || 'moderate';
+        const auditSpinner = new Spinner('Fetching advisory database...').start();
 
-    const level = flags.level || config.auditLevel || 'moderate';
-    const auditSpinner = new Spinner('Fetching advisory database...').start();
+        const { vulnerabilities, stats, total, error } = await auditSec.audit(installed, { level });
+        auditSpinner.succeed('Audit complete');
 
-    const { vulnerabilities, stats, total, error } = await auditSec.audit(installed, { level });
-    auditSpinner.succeed('Audit complete');
+        auditSec.formatAuditResults({ vulnerabilities, stats, total, error });
+
+        if (total > 0) {
+            process.exitCode = 1;
+        }
+    }
+
+    /**
+     * Internal helper to read and add package metadata to the list.
+     * 
+     * @param {string} pkgJsonPath - Path to the package.json file
+     * @param {Object[]} list - Reference to the installed packages list
+     * @private
+     */
+    _tryAddPackage(pkgJsonPath, list) {
+        if (fs.existsSync(pkgJsonPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+                if (pkg.name && pkg.version) {
+                    list.push({ name: pkg.name, version: pkg.version });
+                }
+            } catch (err) {
+                // Silently skip malformed package.json files
+            }
+        }
+    }
+}
 
-    auditSec.formatAuditResults({ vulnerabilities, stats, total, error });
+module.exports = AuditCommand;
 
-    if (total > 0) process.exitCode = 1;
-};

package/src/commands/base-command.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const logger = require('../utils/logger');
+const config = require('../utils/config');
+
+/**
+ * BaseCommand is the abstract base class for all JPM CLI commands.
+ * It provides common infrastructure for argument parsing, validation, and logging.
+ * 
+ * Each command must implement the `run` method.
+ * 
+ * @abstract
+ */
+class BaseCommand {
+    /**
+     * @param {string} name - The canonical name of the command (e.g., 'install')
+     * @param {Object} [options={}] - Command configuration options
+     */
+    constructor(name, options = {}) {
+        /** @type {string} */
+        this.name = name;
+        /** @type {Object} */
+        this.options = options;
+        /** @type {Object} */
+        this.config = config;
+        /** @type {Object} */
+        this.logger = logger;
+    }
+
+    /**
+     * The main execution entry point for the command.
+     * Must be implemented by subclasses.
+     * 
+     * @param {string[]} args - Positional command line arguments
+     * @param {Object} flags - Parsed CLI flags/options
+     * @returns {Promise<void>}
+     * @abstract
+     */
+    async run(args, flags) {
+        throw new Error(`Command "${this.name}" does not implement the run() method.`);
+    }
+
+    /**
+     * Displays command-specific help information.
+     * Can be overridden by subclasses for more detailed help.
+     */
+    help() {
+        this.logger.log(`Usage: jpm ${this.name} [options] [args]`);
+    }
+
+    /**
+     * Validates command arguments. Can be overridden by subclasses.
+     * 
+     * @param {string[]} args - Positional arguments
+     * @returns {boolean} True if arguments are valid
+     */
+    validate(args) {
+        return true;
+    }
+}
+
+module.exports = BaseCommand;

package/src/commands/config.js

@@ -1,59 +1,102 @@
 'use strict';
 
-const config = require('../utils/config');
-const logger = require('../utils/logger');
-
-module.exports = async function configCmd(args, flags) {
-    const [action, key, ...rest] = args;
-    const value = rest.join(' ');
-
-    switch (action) {
-        case 'get':
-            if (!key) { logger.error('Usage: jpm config get <key>'); process.exit(1); }
-            const val = config.get(key);
-            if (val === undefined) { logger.warn(`Key "${key}" not set`); }
-            else { logger.log(String(val)); }
-            break;
-
-        case 'set':
-            if (!key || value === '') { logger.error('Usage: jpm config set <key> <value>'); process.exit(1); }
-            const layer = flags.global ? 'user' : 'project';
-            config.set(key, value, layer);
-            logger.success(`Set ${key} = ${value} (${layer})`);
-            break;
-
-        case 'delete':
-        case 'del':
-            if (!key) { logger.error('Usage: jpm config delete <key>'); process.exit(1); }
-            config.delete(key, flags.global ? 'user' : 'project');
-            logger.success(`Deleted key: ${key}`);
-            break;
-
-        case 'list':
-        case 'ls': {
-            const all = config.list();
-            const rows = Object.entries(all).map(([k, v]) => ({ Key: k, Value: String(v) }));
-            logger.table(rows, ['Key', 'Value']);
-            break;
+const BaseCommand = require('./base-command');
+
+/**
+ * ConfigCommand handles the 'jpm config' commands for managing settings.
+ * It provides subcommands for getting, setting, deleting, and listing configurations.
+ */
+class ConfigCommand extends BaseCommand {
+    constructor() {
+        super('config');
+    }
+
+    /**
+     * Executes the configuration management actions.
+     * 
+     * @param {string[]} args - Action and optional key/value arguments
+     * @param {Object} flags - CLI flags (e.g., --global)
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const [action, key, ...rest] = args;
+        const value = rest.join(' ');
+
+        switch (action) {
+            case 'get':
+                if (!key) {
+                    this.logger.error('Usage: jpm config get <key>');
+                    throw new Error('Key missing for config get.');
+                }
+                const val = this.config.get(key);
+                if (val === undefined) {
+                    this.logger.warn(`Key "${key}" not set`);
+                } else {
+                    this.logger.log(String(val));
+                }
+                break;
+
+            case 'set':
+                if (!key || value === '') {
+                    this.logger.error('Usage: jpm config set <key> <value>');
+                    throw new Error('Key or value missing for config set.');
+                }
+                const layer = flags.global ? 'user' : 'project';
+                this.config.set(key, value, layer);
+                this.logger.success(`Set ${key} = ${value} (${layer})`);
+                break;
+
+            case 'delete':
+            case 'del':
+                if (!key) {
+                    this.logger.error('Usage: jpm config delete <key>');
+                    throw new Error('Key missing for config delete.');
+                }
+                this.config.delete(key, flags.global ? 'user' : 'project');
+                this.logger.success(`Deleted key: ${key}`);
+                break;
+
+            case 'list':
+            case 'ls': {
+                const allConfigs = this.config.list();
+                const rows = Object.entries(allConfigs).map(([k, v]) => ({
+                    Key: k,
+                    Value: String(v)
+                }));
+                this.logger.table(rows, ['Key', 'Value']);
+                break;
+            }
+
+            default:
+                this._renderHelp();
         }
+    }
 
-        default:
-            logger.log(`
-${logger.c.bold('jpm config')} — manage configuration
+    /**
+     * Internal helper to render the config-specific help message.
+     * @private
+     */
+    _renderHelp() {
+        const c = this.logger.c;
+        this.logger.log(`
+${c.bold('jpm config')} — manage configuration
 
-  ${logger.c.cyan('jpm config list')}            List all configuration values
-  ${logger.c.cyan('jpm config get <key>')}       Get a specific value
-  ${logger.c.cyan('jpm config set <key> <val>')} Set a value (project .jpmrc)
-  ${logger.c.cyan('jpm config delete <key>')}    Delete a key
+  ${c.cyan('jpm config list')}            List all configuration values
+  ${c.cyan('jpm config get <key>')}       Get a specific value
+  ${c.cyan('jpm config set <key> <val>')} Set a value (project .jpmrc)
+  ${c.cyan('jpm config delete <key>')}    Delete a key
   
-  ${logger.c.gray('Add --global to modify ~/.jpmrc instead of .jpmrc')}
-
-${logger.c.bold('Common keys:')}
-  registry          ${logger.c.gray('Registry URL (default: https://registry.npmjs.org/)')}
-  loglevel          ${logger.c.gray('Log level: silent|error|warn|info|verbose|debug')}
-  save-exact        ${logger.c.gray('Save exact versions (true/false)')}
-  audit-level       ${logger.c.gray('Minimum audit severity: low|moderate|high|critical')}
-  cache             ${logger.c.gray('Cache directory path')}
+  ${c.gray('Add --global to modify ~/.jpmrc instead of .jpmrc')}
+
+${c.bold('Common keys:')}
+  registry          ${c.gray('Registry URL (default: https://registry.npmjs.org/)')}
+  loglevel          ${c.gray('Log level: silent|error|warn|info|verbose|debug')}
+  save-exact        ${c.gray('Save exact versions (true/false)')}
+  audit-level       ${c.gray('Minimum audit severity: low|moderate|high|critical')}
+  cache             ${c.gray('Cache directory path')}
 `);
     }
-};
+}
+
+module.exports = ConfigCommand;
+

package/src/commands/info.js

@@ -1,78 +1,125 @@
 'use strict';
 
+const BaseCommand = require('./base-command');
 const registry = require('../core/registry');
 const semver = require('../utils/semver');
 const { Spinner } = require('../utils/progress');
-const logger = require('../utils/logger');
-
-module.exports = async function info(args, flags) {
-    if (!args.length) { logger.error('Usage: jpm info <package> [version]'); process.exit(1); }
-
-    let [pkgSpec] = args;
-    let name, version;
-
-    const lastAt = pkgSpec.lastIndexOf('@');
-    if (lastAt > 0) { name = pkgSpec.slice(0, lastAt); version = pkgSpec.slice(lastAt + 1); }
-    else { name = pkgSpec; version = 'latest'; }
-
-    const spinner = new Spinner(`Fetching info for ${name}...`).start();
-
-    let meta, latest, versions, tags;
-    try {
-        [meta, latest, versions, tags] = await Promise.all([
-            registry.getVersion(name, version),
-            registry.getLatest(name),
-            registry.getVersions(name),
-            registry.getDistTags(name),
-        ]);
-        spinner.succeed(`${name}@${meta.version}`);
-    } catch (err) {
-        spinner.fail(`Package "${name}" not found: ${err.message}`);
-        process.exit(1);
-    }
 
-    const c = logger.c;
-    logger.log('');
-    logger.log(`${c.bold(meta.name)} ${c.gray(`v${meta.version}`)}`);
-    if (meta.description) logger.log(meta.description);
-
-    logger.log('');
-    logger.log(`${c.cyan('latest')}      ${latest}`);
-    logger.log(`${c.cyan('license')}     ${meta.license || 'n/a'}`);
-    logger.log(`${c.cyan('author')}      ${typeof meta.author === 'object' ? meta.author.name : (meta.author || 'n/a')}`);
-    if (meta.homepage) logger.log(`${c.cyan('homepage')}    ${meta.homepage}`);
-    if (meta.repository?.url) logger.log(`${c.cyan('repository')}  ${meta.repository.url.replace('git+', '')}`);
-
-    // Keywords
-    if (meta.keywords?.length) {
-        logger.log(`${c.cyan('keywords')}    ${meta.keywords.slice(0, 10).join(', ')}`);
+/**
+ * InfoCommand handles the 'jpm info' and 'jpm view' commands.
+ * It fetches and displays detailed metadata about a specific package and version.
+ */
+class InfoCommand extends BaseCommand {
+    constructor() {
+        super('info');
     }
 
-    // Dist-tags
-    if (Object.keys(tags).length > 1) {
-        logger.log('');
-        logger.section('Tags');
-        for (const [tag, ver] of Object.entries(tags)) {
-            logger.log(`  ${tag.padEnd(12)} ${ver}`);
+    /**
+     * Executes the package information retrieval.
+     * 
+     * @param {string[]} args - Package specification (e.g., 'pkg@1.2.3' or 'pkg')
+     * @param {Object} flags - CLI flags
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        if (!args.length) {
+            this.logger.error('Usage: jpm info <package> [version]');
+            throw new Error('No package name provided.');
         }
-    }
 
-    // Dependencies
-    const deps = meta.dependencies || {};
-    if (Object.keys(deps).length) {
-        logger.log('');
-        logger.section('Dependencies');
-        for (const [dep, range] of Object.entries(deps)) {
-            logger.log(`  ${c.cyan(dep.padEnd(30))} ${range}`);
+        let [pkgSpec] = args;
+        let name, version;
+
+        // Parse name and version from spec (handling scoped packages)
+        const lastAt = pkgSpec.lastIndexOf('@');
+        if (lastAt > 0 && !(pkgSpec.startsWith('@') && pkgSpec.indexOf('@', 1) === -1)) {
+            name = pkgSpec.slice(0, lastAt);
+            version = pkgSpec.slice(lastAt + 1);
+        } else {
+            name = pkgSpec;
+            version = 'latest';
         }
+
+        const spinner = new Spinner(`Fetching info for ${name}...`).start();
+
+        try {
+            const [meta, latest, versions, tags] = await Promise.all([
+                registry.getVersion(name, version),
+                registry.getLatest(name),
+                registry.getVersions(name),
+                registry.getDistTags(name),
+            ]);
+            spinner.succeed(`${name}@${meta.version}`);
+
+            const c = this.logger.c;
+            this.logger.log('');
+            this.logger.log(`${c.bold(meta.name)} ${c.gray(`v${meta.version}`)}`);
+            if (meta.description) {
+                this.logger.log(meta.description);
+            }
+
+            this.logger.log('');
+            this.logger.log(`${c.cyan('latest')}      ${latest}`);
+            this.logger.log(`${c.cyan('license')}     ${meta.license || 'n/a'}`);
+            this.logger.log(`${c.cyan('author')}      ${this._formatAuthor(meta.author)}`);
+            if (meta.homepage) {
+                this.logger.log(`${c.cyan('homepage')}    ${meta.homepage}`);
+            }
+            if (meta.repository?.url) {
+                this.logger.log(`${c.cyan('repository')}  ${meta.repository.url.replace('git+', '')}`);
+            }
+
+            // Render keywords
+            if (meta.keywords?.length) {
+                this.logger.log(`${c.cyan('keywords')}    ${meta.keywords.slice(0, 10).join(', ')}`);
+            }
+
+            // Render distribution tags
+            if (Object.keys(tags).length > 1) {
+                this.logger.log('');
+                this.logger.section('Tags');
+                for (const [tag, ver] of Object.entries(tags)) {
+                    this.logger.log(`  ${tag.padEnd(12)} ${ver}`);
+                }
+            }
+
+            // Render dependencies
+            const deps = meta.dependencies || {};
+            if (Object.keys(deps).length) {
+                this.logger.log('');
+                this.logger.section('Dependencies');
+                for (const [dep, range] of Object.entries(deps)) {
+                    this.logger.log(`  ${c.cyan(dep.padEnd(30))} ${range}`);
+                }
+            }
+
+            // Render recent versions
+            const recentVersions = semver.rsort(versions).slice(0, 10);
+            this.logger.log('');
+            this.logger.section(`Versions (latest 10 of ${versions.length})`);
+            this.logger.log('  ' + recentVersions.join('  '));
+
+            this.logger.log('');
+            this.logger.log(c.gray(`jpm install ${name}@${meta.version}`));
+        } catch (err) {
+            spinner.fail(`Package "${name}" not found: ${err.message}`);
+            throw err;
+        }
+    }
+
+    /**
+     * Formats author information into a readable string.
+     * 
+     * @param {string|Object} author - Author data from package.json
+     * @returns {string} Formatted author string
+     * @private
+     */
+    _formatAuthor(author) {
+        if (!author) return 'n/a';
+        if (typeof author === 'object') return author.name || 'n/a';
+        return author;
     }
+}
 
-    // Recent versions
-    const recentVersions = semver.rsort(versions).slice(0, 10);
-    logger.log('');
-    logger.section(`Versions (latest 10 of ${versions.length})`);
-    logger.log('  ' + recentVersions.join('  '));
+module.exports = InfoCommand;
 
-    logger.log('');
-    logger.log(c.gray(`jpm install ${name}@${meta.version}`));
-};