jpm-pkg 1.0.3 → 1.0.4

package/src/commands/run.js

@@ -2,71 +2,105 @@
 
 const { spawnSync } = require('node:child_process');
 const path = require('node:path');
+const BaseCommand = require('./base-command');
 const PackageJSON = require('../core/package-json');
-const logger = require('../utils/logger');
 
-module.exports = async function run(args, flags) {
-    const [scriptName, ...scriptArgs] = args;
-    const cwd = process.cwd();
-    const pkgJson = PackageJSON.fromDir(cwd);
-    const scripts = pkgJson.scripts;
+/**
+ * RunCommand handles the 'jpm run' command.
+ * It executes scripts defined in package.json, supporting pre/post hooks.
+ */
+class RunCommand extends BaseCommand {
+    constructor() {
+        super('run');
+    }
+
+    /**
+     * Executes a specified script from package.json.
+     * 
+     * @param {string[]} args - Positional arguments (script name and optional parameters)
+     * @param {Object} flags - CLI flags
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const [scriptName, ...scriptArgs] = args;
+        const cwd = process.cwd();
+        const pkgJson = PackageJSON.fromDir(cwd);
+        const scripts = pkgJson.scripts;
 
-    // `jpm run` with no script — list available scripts
-    if (!scriptName) {
-        logger.section('Available scripts:');
-        if (!Object.keys(scripts).length) {
-            logger.info('No scripts defined in package.json');
+        // If no script name provided, list all available scripts
+        if (!scriptName) {
+            this.logger.section('Available scripts:');
+            const scriptEntries = Object.entries(scripts);
+            if (!scriptEntries.length) {
+                this.logger.info('No scripts defined in package.json');
+                return;
+            }
+            for (const [name, cmd] of scriptEntries) {
+                this.logger.log(`  ${this.logger.c.cyan(name.padEnd(20))} ${this.logger.c.gray(cmd)}`);
+            }
             return;
         }
-        for (const [name, cmd] of Object.entries(scripts)) {
-            logger.log(`  ${logger.c.cyan(name.padEnd(20))} ${logger.c.gray(cmd)}`);
-        }
-        return;
-    }
 
-    if (!scripts[scriptName]) {
-        logger.error(`Script "${scriptName}" not found in package.json`);
-        logger.info(`Available: ${Object.keys(scripts).join(', ')}`);
-        process.exit(1);
-    }
+        if (!scripts[scriptName]) {
+            this.logger.error(`Script "${scriptName}" not found in package.json`);
+            this.logger.info(`Available: ${Object.keys(scripts).join(', ')}`);
+            throw new Error(`Script "${scriptName}" not found.`);
+        }
 
-    // Pre-hook: check for 'pre<script>'
-    if (scripts[`pre${scriptName}`]) {
-        logger.info(`> ${pkgJson.name} pre${scriptName}`);
-        run_script(`pre${scriptName}`, scripts, cwd, scriptArgs);
-    }
+        // Execute pre-hook if it exists
+        const preHook = `pre${scriptName}`;
+        if (scripts[preHook]) {
+            this.logger.info(`> ${pkgJson.name} ${preHook}`);
+            this._executeScript(preHook, scripts, cwd, scriptArgs);
+        }
 
-    logger.info(`\n> ${pkgJson.name} ${scriptName}`);
-    logger.info(`> ${scripts[scriptName]}\n`);
+        this.logger.info(`\n> ${pkgJson.name} ${scriptName}`);
+        this.logger.info(`> ${scripts[scriptName]}\n`);
 
-    const result = run_script(scriptName, scripts, cwd, scriptArgs);
+        const result = this._executeScript(scriptName, scripts, cwd, scriptArgs);
 
-    // Post-hook: check for 'post<script>'
-    if (scripts[`post${scriptName}`]) {
-        logger.info(`> ${pkgJson.name} post${scriptName}`);
-        run_script(`post${scriptName}`, scripts, cwd, scriptArgs);
-    }
+        // Execute post-hook if it exists
+        const postHook = `post${scriptName}`;
+        if (scripts[postHook]) {
+            this.logger.info(`> ${pkgJson.name} ${postHook}`);
+            this._executeScript(postHook, scripts, cwd, scriptArgs);
+        }
 
-    if (result.status !== 0) {
-        logger.error(`Script "${scriptName}" exited with code ${result.status}`);
-        process.exit(result.status || 1);
+        if (result.status !== 0) {
+            const code = result.status || 1;
+            this.logger.error(`Script "${scriptName}" exited with code ${code}`);
+            process.exit(code);
+        }
     }
-};
 
-function run_script(name, scripts, cwd, extraArgs) {
-    const cmd = scripts[name] + (extraArgs.length ? ' ' + extraArgs.join(' ') : '');
+    /**
+     * Internal helper to spawn a process for a script.
+     * Adds node_modules/.bin to the PATH.
+     * 
+     * @param {string} name - Script name to run
+     * @param {Object} scripts - Script definitions from package.json
+     * @param {string} cwd - Current working directory
+     * @param {string[]} extraArgs - Additional arguments to pass to the script
+     * @returns {import('node:child_process').SpawnSyncReturns<Buffer>}
+     * @private
+     */
+    _executeScript(name, scripts, cwd, extraArgs) {
+        const cmd = scripts[name] + (extraArgs.length ? ' ' + extraArgs.join(' ') : '');
 
-    // Add local .bin to PATH so locally installed binaries work
-    const binPath = path.join(cwd, 'node_modules', '.bin');
-    const env = {
-        ...process.env,
-        PATH: `${binPath}${process.platform === 'win32' ? ';' : ':'}${process.env.PATH}`,
-    };
+        const binPath = path.join(cwd, 'node_modules', '.bin');
+        const env = {
+            ...process.env,
+            PATH: `${binPath}${process.platform === 'win32' ? ';' : ':'}${process.env.PATH}`,
+        };
 
-    return spawnSync(cmd, {
-        cwd,
-        shell: true,
-        stdio: 'inherit',
-        env,
-    });
+        return spawnSync(cmd, {
+            cwd,
+            shell: true,
+            stdio: 'inherit',
+            env,
+        });
+    }
 }
+
+module.exports = RunCommand;
+

package/src/commands/search.js

@@ -1,41 +1,65 @@
 'use strict';
 
+const BaseCommand = require('./base-command');
 const registry = require('../core/registry');
 const { Spinner } = require('../utils/progress');
-const logger = require('../utils/logger');
 
-module.exports = async function search(args, flags) {
-    const query = args.join(' ');
-    if (!query) { logger.error('Usage: jpm search <query>'); process.exit(1); }
+/**
+ * SearchCommand handles the 'jpm search' and 'jpm find' commands.
+ * It queries the registry for packages matching a search term and displays results.
+ */
+class SearchCommand extends BaseCommand {
+    constructor() {
+        super('search');
+    }
+
+    /**
+     * Executes the package search.
+     * 
+     * @param {string[]} args - Search query terms
+     * @param {Object} flags - CLI flags (e.g., --size)
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const query = args.join(' ');
+        if (!query) {
+            this.logger.error('Usage: jpm search <query>');
+            throw new Error('No search query provided.');
+        }
+
+        const size = parseInt(flags.size || flags.n || '20', 10);
+        const spinner = new Spinner(`Searching for "${query}"...`).start();
 
-    const size = parseInt(flags.size || flags.n || '20', 10);
-    const spinner = new Spinner(`Searching for "${query}"...`).start();
+        try {
+            const results = await registry.search(query, { size });
+            spinner.succeed(`Found ${results.length} result(s) for "${query}"`);
 
-    let results;
-    try {
-        results = await registry.search(query, { size });
-    } catch (err) {
-        spinner.fail(`Search failed: ${err.message}`);
-        process.exit(1);
+            if (!results.length) {
+                this.logger.info('No packages found.');
+                return;
+            }
+
+            this.logger.log('');
+            const rows = results.map(r => ({
+                Name: r.package?.name || '',
+                Version: r.package?.version || '',
+                Description: (r.package?.description || '').slice(0, 55),
+                Downloads: r.downloads?.weekly != null
+                    ? r.downloads.weekly.toLocaleString()
+                    : 'n/a',
+                Score: r.score?.final != null
+                    ? (r.score.final * 100).toFixed(0) + '%'
+                    : 'n/a',
+            }));
+
+            this.logger.table(rows, ['Name', 'Version', 'Description', 'Downloads', 'Score']);
+            this.logger.log(`\n${this.logger.c.gray('Run `jpm info <package>` for details. `jpm install <package>` to install.')}`);
+        } catch (err) {
+            spinner.fail(`Search failed: ${err.message}`);
+            throw err;
+        }
     }
+}
+
+module.exports = SearchCommand;
 
-    spinner.succeed(`Found ${results.length} result(s) for "${query}"`);
-
-    if (!results.length) { logger.info('No packages found.'); return; }
-
-    logger.log('');
-    const rows = results.map(r => ({
-        Name: r.package?.name || '',
-        Version: r.package?.version || '',
-        Description: (r.package?.description || '').slice(0, 55),
-        Downloads: r.downloads?.weekly != null
-            ? r.downloads.weekly.toLocaleString()
-            : 'n/a',
-        Score: r.score?.final != null
-            ? (r.score.final * 100).toFixed(0) + '%'
-            : 'n/a',
-    }));
-    logger.table(rows, ['Name', 'Version', 'Description', 'Downloads', 'Score']);
-
-    logger.log(`\n${logger.c.gray('Run `jpm info <package>` for details. `jpm install <package>` to install.')}`);
-};

package/src/commands/uninstall.js

@@ -1,48 +1,65 @@
 'use strict';
 
+const BaseCommand = require('./base-command');
 const PackageJSON = require('../core/package-json');
 const Installer = require('../core/installer');
 const Lockfile = require('../core/lockfile');
-const Resolver = require('../core/resolver');
 const { Spinner } = require('../utils/progress');
-const logger = require('../utils/logger');
 
-module.exports = async function uninstall(args, flags) {
-    if (!args.length) {
-        logger.error('Usage: jpm uninstall <package> [package2 ...]');
-        process.exit(1);
+/**
+ * UninstallCommand handles the 'jpm uninstall' command and its aliases.
+ * It removes packages from node_modules and updates package.json and the lockfile.
+ */
+class UninstallCommand extends BaseCommand {
+    constructor() {
+        super('uninstall');
     }
 
-    const cwd = process.cwd();
-    const pkgJson = PackageJSON.fromDir(cwd);
-    const lockfile = new Lockfile(cwd);
-    const installer = new Installer(cwd);
+    /**
+     * Executes the uninstallation process for one or more packages.
+     * 
+     * @param {string[]} args - Names of packages to uninstall
+     * @param {Object} flags - CLI flags
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        if (!args.length) {
+            this.logger.error('Usage: jpm uninstall <package> [package2 ...]');
+            throw new Error('No package names provided for uninstallation.');
+        }
 
-    for (const name of args) {
-        const spinner = new Spinner(`Removing ${name}...`).start();
+        const cwd = process.cwd();
+        const pkgJson = PackageJSON.fromDir(cwd);
+        const lockfile = new Lockfile(cwd);
+        const installer = new Installer(cwd);
 
-        const removed = await installer.uninstall(name);
-        if (!removed) {
-            spinner.warn(`${name} was not installed`);
-            continue;
-        }
+        for (const name of args) {
+            const spinner = new Spinner(`Removing ${name}...`).start();
+
+            const removed = await installer.uninstall(name);
+            if (!removed) {
+                spinner.warn(`${name} was not installed`);
+                continue;
+            }
 
-        // Remove from package.json
-        pkgJson.removeDependency(name);
+            // Remove from package.json
+            pkgJson.removeDependency(name);
 
-        // Remove from lock file — remove all entries with this name
-        const toRemove = lockfile.allPackages()
-            .filter(p => p.name === name)
-            .map(p => ({ name: p.name, version: p.version }));
+            // Remove from lock file (remove all versions for this package name)
+            const lockedPackages = lockfile.allPackages();
+            for (const pkg of lockedPackages) {
+                if (pkg.name === name) {
+                    lockfile.removePackage(pkg.name, pkg.version);
+                }
+            }
 
-        for (const { name: n, version: v } of toRemove) {
-            lockfile.removePackage(n, v);
+            spinner.succeed(`Removed ${name}`);
         }
 
-        spinner.succeed(`Removed ${name}`);
+        pkgJson.save();
+        lockfile.save();
+        this.logger.success(`\nRemoved ${args.length} package(s)`);
     }
+}
 
-    pkgJson.save();
-    lockfile.save();
-    logger.success(`\nRemoved ${args.length} package(s)`);
-};
+module.exports = UninstallCommand;

package/src/commands/update.js

@@ -1,63 +1,104 @@
 'use strict';
 
+const BaseCommand = require('./base-command');
 const PackageJSON = require('../core/package-json');
 const registry = require('../core/registry');
 const semver = require('../utils/semver');
 const { Spinner } = require('../utils/progress');
-const logger = require('../utils/logger');
-
-/** jpm update [pkg] | jpm outdated */
-module.exports = async function update(args, flags, command) {
-    const cwd = process.cwd();
-    const pkgJson = PackageJSON.fromDir(cwd);
-    const allDeps = pkgJson.allDeps();
-
-    const targets = args.length
-        ? args.reduce((acc, n) => { if (allDeps[n]) acc[n] = allDeps[n]; return acc; }, {})
-        : allDeps;
-
-    const spinner = new Spinner(`Checking ${Object.keys(targets).length} packages for updates...`).start();
-    const rows = [];
-
-    await Promise.all(
-        Object.entries(targets).map(async ([name, range]) => {
-            try {
-                const versions = await registry.getVersions(name);
-                const latest = await registry.getLatest(name);
-                const current = semver.maxSatisfying(versions, range);
-                const wanted = semver.maxSatisfying(versions, range);
-                const isOutdated = latest && current && semver.gt(latest, current);
-
-                rows.push({
-                    Package: name,
-                    Current: current || 'n/a',
-                    Wanted: wanted || 'n/a',
-                    Latest: latest || 'n/a',
-                    Status: isOutdated
-                        ? logger.c.yellow('outdated')
-                        : logger.c.green('up to date'),
-                });
-            } catch {
-                rows.push({ Package: name, Current: '?', Wanted: '?', Latest: '?', Status: logger.c.red('error') });
+
+/**
+ * UpdateCommand handles the 'jpm update' and 'jpm outdated' commands.
+ * It checks for newer versions of installed packages and can perform updates.
+ */
+class UpdateCommand extends BaseCommand {
+    constructor() {
+        super('update');
+    }
+
+    /**
+     * Executes the update or outdated check.
+     * 
+     * @param {string[]} args - Optional package names to limit the check
+     * @param {Object} flags - CLI flags
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const cwd = process.cwd();
+        const pkgJson = PackageJSON.fromDir(cwd);
+        const allDeps = pkgJson.allDeps();
+
+        const targets = args.length
+            ? args.reduce((acc, n) => { if (allDeps[n]) acc[n] = allDeps[n]; return acc; }, {})
+            : allDeps;
+
+        if (Object.keys(targets).length === 0) {
+            this.logger.info('No dependencies found to check.');
+            return;
+        }
+
+        const spinner = new Spinner(`Checking ${Object.keys(targets).length} packages for updates...`).start();
+        const rows = [];
+
+        await Promise.all(
+            Object.entries(targets).map(async ([name, range]) => {
+                try {
+                    const versions = await registry.getVersions(name);
+                    const latest = await registry.getLatest(name);
+                    const current = semver.maxSatisfying(versions, range);
+                    const wanted = semver.maxSatisfying(versions, range);
+                    const isOutdated = latest && current && semver.gt(latest, current);
+
+                    rows.push({
+                        Package: name,
+                        Current: current || 'n/a',
+                        Wanted: wanted || 'n/a',
+                        Latest: latest || 'n/a',
+                        Status: isOutdated
+                            ? this.logger.c.yellow('outdated')
+                            : this.logger.c.green('up to date'),
+                    });
+                } catch (err) {
+                    rows.push({
+                        Package: name,
+                        Current: '?',
+                        Wanted: '?',
+                        Latest: '?',
+                        Status: this.logger.c.red('error')
+                    });
+                }
+            })
+        );
+
+        spinner.succeed('Done');
+
+        // Handle 'outdated' alias/mode
+        if (this.name === 'outdated' || flags.outdated) {
+            const outdated = rows.filter(r => r.Status.includes('outdated'));
+            if (!outdated.length) {
+                this.logger.success('All packages are up to date!');
+                return;
             }
-        })
-    );
+            this.logger.table(outdated, ['Package', 'Current', 'Wanted', 'Latest', 'Status']);
+            return;
+        }
+
+        // Filter for packages that actually need updating
+        const outdatedPkgs = rows.filter(r => r.Status.includes('outdated'));
+        if (!outdatedPkgs.length) {
+            this.logger.success('All packages are up to date!');
+            return;
+        }
+
+        this.logger.info(`Updating ${outdatedPkgs.length} package(s)...`);
 
-    spinner.succeed('Done');
+        // Use dynamic import/require to avoid circular dependency with InstallCommand
+        const InstallCommand = require('./install');
+        const installInstance = new InstallCommand();
 
-    if (command === 'outdated') {
-        const outdated = rows.filter(r => r.Status.includes('outdated'));
-        if (!outdated.length) { logger.success('All packages are up to date!'); return; }
-        logger.table(outdated, ['Package', 'Current', 'Wanted', 'Latest', 'Status']);
-        return;
+        const pkgArgs = outdatedPkgs.map(p => `${p.Package}@${p.Latest}`);
+        await installInstance.run(pkgArgs, flags);
     }
+}
 
-    // Actually update
-    const outdatedPkgs = rows.filter(r => r.Status.includes('outdated'));
-    if (!outdatedPkgs.length) { logger.success('All packages are up to date!'); return; }
+module.exports = UpdateCommand;
 
-    logger.info(`Updating ${outdatedPkgs.length} package(s)...`);
-    const installCmd = require('./install');
-    const pkgArgs = outdatedPkgs.map(p => `${p.Package}@${p.Latest}`);
-    await installCmd(pkgArgs, flags);
-};