jpm-pkg 1.0.3 → 1.0.5

package/src/commands/list.js

@@ -2,102 +2,148 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const BaseCommand = require('./base-command');
 const PackageJSON = require('../core/package-json');
 const { formatBytes } = require('../utils/fs');
-const logger = require('../utils/logger');
 
-module.exports = async function list(args, flags) {
-    const cwd = process.cwd();
-    const depth = parseInt(flags.depth ?? flags.d ?? '0', 10);
-    const json = flags.json;
-    const nodeModules = path.join(cwd, 'node_modules');
-
-    const pkgJson = PackageJSON.fromDir(cwd);
-
-    if (!fs.existsSync(nodeModules)) {
-        logger.warn('No node_modules found. Run `jpm install` first.');
-        return;
+/**
+ * ListCommand handles the 'jpm list', 'jpm ls', and 'jpm peek' commands.
+ * It visualizes the installed dependency tree and package sizes.
+ */
+class ListCommand extends BaseCommand {
+    constructor() {
+        super('list');
     }
 
-    // Collect top-level installed packages
-    const installed = [];
-    for (const entry of fs.readdirSync(nodeModules, { withFileTypes: true })) {
-        if (entry.name.startsWith('.')) continue;
+    /**
+     * Executes the listing and visualization of dependencies.
+     * 
+     * @param {string[]} args - Optional arguments
+     * @param {Object} flags - CLI flags (e.g., --depth, --json)
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const cwd = process.cwd();
+        const depth = parseInt(flags.depth ?? flags.d ?? '0', 10);
+        const isJson = flags.json;
+        const nodeModules = path.join(cwd, 'node_modules');
+
+        const pkgJson = PackageJSON.fromDir(cwd);
+
+        if (!fs.existsSync(nodeModules)) {
+            this.logger.warn('No node_modules found. Run `jpm install` first.');
+            return;
+        }
 
-        if (entry.name.startsWith('@') && entry.isDirectory()) {
-            const scopeDir = path.join(nodeModules, entry.name);
-            for (const scoped of fs.readdirSync(scopeDir, { withFileTypes: true })) {
-                const pkg = readPkg(path.join(scopeDir, scoped.name));
+        // 1. Collect installed packages
+        const installed = [];
+        for (const entry of fs.readdirSync(nodeModules, { withFileTypes: true })) {
+            if (entry.name.startsWith('.')) continue;
+
+            if (entry.name.startsWith('@') && entry.isDirectory()) {
+                const scopeDir = path.join(nodeModules, entry.name);
+                for (const scoped of fs.readdirSync(scopeDir, { withFileTypes: true })) {
+                    const pkg = this._readPkg(path.join(scopeDir, scoped.name));
+                    if (pkg) installed.push(pkg);
+                }
+            } else if (entry.isDirectory()) {
+                const pkg = this._readPkg(path.join(nodeModules, entry.name));
                 if (pkg) installed.push(pkg);
             }
-        } else if (entry.isDirectory()) {
-            const pkg = readPkg(path.join(nodeModules, entry.name));
-            if (pkg) installed.push(pkg);
         }
-    }
 
-    // Sort alphabetically
-    installed.sort((a, b) => a.name.localeCompare(b.name));
+        // 2. Sort results alphabetically
+        installed.sort((a, b) => a.name.localeCompare(b.name));
 
-    if (json) {
-        process.stdout.write(JSON.stringify({ name: pkgJson.name, dependencies: toObj(installed) }, null, 2) + '\n');
-        return;
-    }
+        // 3. Handle JSON output mode
+        if (isJson) {
+            process.stdout.write(JSON.stringify({
+                name: pkgJson.name,
+                dependencies: this._toObj(installed)
+            }, null, 2) + '\n');
+            return;
+        }
+
+        // 4. Render terminal tree view
+        this.logger.log(`\n${this.logger.c.bold(pkgJson.name)}@${pkgJson.version}`);
+
+        const directDeps = new Set([
+            ...Object.keys(pkgJson.dependencies),
+            ...Object.keys(pkgJson.devDependencies),
+        ]);
+
+        const total = installed.length;
+        let totalSize = 0;
+
+        for (let i = 0; i < installed.length; i++) {
+            const pkg = installed[i];
+            const isLast = i === installed.length - 1;
+            const devMark = Object.keys(pkgJson.devDependencies).includes(pkg.name)
+                ? this.logger.c.gray(' dev')
+                : '';
+
+            const conn = isLast ? '└── ' : '├── ';
+            const nameStr = this.logger.c.cyan(pkg.name);
+            const verStr = this.logger.c.gray(`@${pkg.version}`);
+            this.logger.log(`${conn}${nameStr}${verStr}${devMark}`);
+
+            if (depth > 0 && pkg.dependencies) {
+                const subDeps = Object.entries(pkg.dependencies);
+                subDeps.forEach(([depName, depRange], j) => {
+                    const isLastSub = j === subDeps.length - 1;
+                    const ext = isLast ? '    ' : '│   ';
+                    const subConn = isLastSub ? '└── ' : '├── ';
+                    this.logger.log(`${ext}${subConn}${this.logger.c.gray(depName)} ${this.logger.c.gray(depRange)}`);
+                });
+            }
 
-    logger.log(`\n${logger.c.bold(pkgJson.name)}@${pkgJson.version}`);
-
-    const directDeps = new Set([
-        ...Object.keys(pkgJson.dependencies),
-        ...Object.keys(pkgJson.devDependencies),
-    ]);
-
-    const total = installed.length;
-    let totalSize = 0;
-
-    for (let i = 0; i < installed.length; i++) {
-        const pkg = installed[i];
-        const isLast = i === installed.length - 1;
-        const isDir = directDeps.has(pkg.name);
-        const devMark = Object.keys(pkgJson.devDependencies).includes(pkg.name)
-            ? logger.c.gray(' dev')
-            : '';
-
-        const conn = isLast ? '└── ' : '├── ';
-        const nameStr = logger.c.cyan(pkg.name);
-        const verStr = logger.c.gray(`@${pkg.version}`);
-        logger.log(`${conn}${nameStr}${verStr}${devMark}`);
-
-        if (depth > 0 && pkg.dependencies) {
-            const subDeps = Object.entries(pkg.dependencies);
-            subDeps.forEach(([depName, depRange], j) => {
-                const isLastSub = j === subDeps.length - 1;
-                const ext = isLast ? '    ' : '│   ';
-                const subConn = isLastSub ? '└── ' : '├── ';
-                logger.log(`${ext}${subConn}${logger.c.gray(depName)} ${logger.c.gray(depRange)}`);
-            });
+            totalSize += pkg.size || 0;
         }
 
-        totalSize += pkg.size || 0;
+        this.logger.log(`\n${total} packages  ${formatBytes(totalSize)}`);
     }
 
-    logger.log(`\n${total} packages  ${formatBytes(totalSize)}`);
-};
-
-function readPkg(dir) {
-    const f = path.join(dir, 'package.json');
-    try {
-        const data = JSON.parse(fs.readFileSync(f, 'utf8'));
-        let size = 0;
+    /**
+     * Reads package metadata and calculates directory size.
+     * 
+     * @param {string} dir - Directory path to the package
+     * @returns {Object|null} Package data object or null on failure
+     * @private
+     */
+    _readPkg(dir) {
+        const pkgJsonFile = path.join(dir, 'package.json');
         try {
-            for (const file of fs.readdirSync(dir)) {
-                const s = fs.statSync(path.join(dir, file));
-                if (s.isFile()) size += s.size;
-            }
-        } catch { }
-        return { name: data.name, version: data.version, dependencies: data.dependencies, size };
-    } catch { return null; }
-}
+            const data = JSON.parse(fs.readFileSync(pkgJsonFile, 'utf8'));
+            let size = 0;
+            try {
+                // Shallow size calculation (top-level files only)
+                for (const file of fs.readdirSync(dir)) {
+                    const s = fs.statSync(path.join(dir, file));
+                    if (s.isFile()) size += s.size;
+                }
+            } catch (err) { }
+            return {
+                name: data.name,
+                version: data.version,
+                dependencies: data.dependencies,
+                size
+            };
+        } catch (err) {
+            return null;
+        }
+    }
 
-function toObj(arr) {
-    return Object.fromEntries(arr.map(p => [p.name, { version: p.version }]));
+    /**
+     * Converts an array of package objects into a structured object for JSON output.
+     * 
+     * @param {Object[]} arr - Array of package metadata
+     * @returns {Object}
+     * @private
+     */
+    _toObj(arr) {
+        return Object.fromEntries(arr.map(p => [p.name, { version: p.version }]));
+    }
 }
+
+module.exports = ListCommand;
+

package/src/commands/publish.js

@@ -2,147 +2,178 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const crypto = require('node:crypto');
 const tar = require('tar');
+const BaseCommand = require('./base-command');
 const PackageJSON = require('../core/package-json');
 const integrity = require('../security/integrity');
-const { getJSON } = require('../utils/http');
-const { tempDir, mkdirp } = require('../utils/fs');
+const { getJSON, request } = require('../utils/http');
+const { tempDir } = require('../utils/fs');
 const { Spinner } = require('../utils/progress');
-const logger = require('../utils/logger');
-const config = require('../utils/config');
-
-module.exports = async function publish(args, flags) {
-    const cwd = process.cwd();
-    const pkgJson = PackageJSON.fromDir(cwd);
-
-    // 1. Validate
-    const errors = pkgJson.validate();
-    if (errors.length) {
-        logger.error('package.json validation failed:');
-        errors.forEach(e => logger.error(`  ${e}`));
-        process.exit(1);
+
+/**
+ * PublishCommand handles the 'jpm publish' and 'jpm ship' commands.
+ * It validates a package, packs it into a tarball, and uploads it to the registry.
+ */
+class PublishCommand extends BaseCommand {
+    constructor() {
+        super('publish');
     }
 
-    const { name, version } = pkgJson;
-    const registry = config.registry.replace(/\/$/, '');
+    /**
+     * Executes the package publishing process.
+     * 
+     * @param {string[]} args - Optional arguments
+     * @param {Object} flags - CLI flags (e.g., --otp)
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const cwd = process.cwd();
+        const pkgJson = PackageJSON.fromDir(cwd);
+
+        // 1. Validate package configuration
+        const errors = pkgJson.validate();
+        if (errors.length) {
+            this.logger.error('package.json validation failed:');
+            errors.forEach(e => this.logger.error(`  ${e}`));
+            throw new Error('Package validation failed.');
+        }
 
-    logger.section(`Publishing ${name}@${version}`);
+        const { name, version } = pkgJson;
+        const registryUrl = this.config.registry.replace(/\/$/, '');
 
-    // 2. Check auth token
-    const token = config.get('//registry.npmjs.org/:_authToken') || config.get('_authToken');
-    if (!token) {
-        logger.error('Not logged in. Set _authToken in ~/.jpmrc or run: npm login');
-        process.exit(1);
-    }
+        this.logger.section(`Publishing ${name}@${version}`);
 
-    // 3. Check if version already exists
-    const spinner = new Spinner('Checking if version exists...').start();
-    try {
-        const existing = await getJSON(`${registry}/${encodeURIComponent(name)}/${version}`);
-        spinner.fail(`Version ${name}@${version} already exists in registry`);
-        process.exit(1);
-    } catch (err) {
-        if (err.status !== 404) {
-            spinner.warn('Could not verify version uniqueness, continuing...');
-        } else {
-            spinner.succeed('Version check passed');
+        // 2. Resolve authentication token
+        const token = this.config.get('//registry.npmjs.org/:_authToken') || this.config.get('_authToken');
+        if (!token) {
+            this.logger.error('Not logged in. Set _authToken in ~/.jpmrc or run: npm login');
+            throw new Error('Authentication required.');
         }
-    }
 
-    // 4. Create tarball
-    const tmp = tempDir('jpm-publish-');
-    const tgz = path.join(tmp, `${name.replace('@', '').replace('/', '-')}-${version}.tgz`);
-
-    const packSpinner = new Spinner('Packing tarball...').start();
-
-    // Collect files respecting .npmignore / default ignore list
-    const ignore = getIgnoreList(cwd);
-    await tar.create(
-        { gzip: true, file: tgz, cwd, prefix: 'package' },
-        getFilesToPack(cwd, ignore)
-    );
-
-    const tgzStat = fs.statSync(tgz);
-    const shasum = await integrity.hashFile(tgz, 'sha1', 'hex');
-    const integrityH = await integrity.generateIntegrity(tgz);
-    const tgzBase64 = fs.readFileSync(tgz).toString('base64');
-
-    packSpinner.succeed(`Packed ${logger.c.gray(`(${(tgzStat.size / 1024).toFixed(1)} KB)`)}`);
-
-    // 5. Build publish body
-    const body = {
-        _id: name,
-        name,
-        'dist-tags': { latest: version },
-        versions: {
-            [version]: {
-                ...pkgJson.data,
-                dist: {
-                    shasum,
-                    integrity: integrityH,
-                    tarball: `${registry}/${encodeURIComponent(name)}/-/${name}-${version}.tgz`,
+        // 3. Prevent overwriting existing versions
+        const spinner = new Spinner('Checking if version exists...').start();
+        try {
+            await getJSON(`${registryUrl}/${encodeURIComponent(name)}/${version}`);
+            spinner.fail(`Version ${name}@${version} already exists in registry`);
+            throw new Error(`Version ${version} already exists.`);
+        } catch (err) {
+            if (err.status !== 404) {
+                spinner.warn('Could not verify version uniqueness, continuing...');
+            } else {
+                spinner.succeed('Version check passed');
+            }
+        }
+
+        // 4. Create and pack tarball
+        const tmp = tempDir('jpm-publish-');
+        const tgz = path.join(tmp, `${name.replace('@', '').replace('/', '-')}-${version}.tgz`);
+
+        const packSpinner = new Spinner('Packing tarball...').start();
+        const ignore = this._getIgnoreList(cwd);
+
+        await tar.create(
+            { gzip: true, file: tgz, cwd, prefix: 'package' },
+            this._getFilesToPack(cwd, ignore)
+        );
+
+        const tgzStat = fs.statSync(tgz);
+        const shasum = await integrity.hashFile(tgz, 'sha1', 'hex');
+        const integrityH = await integrity.generateIntegrity(tgz);
+        const tgzBase64 = fs.readFileSync(tgz).toString('base64');
+
+        packSpinner.succeed(`Packed ${this.logger.c.gray(`(${(tgzStat.size / 1024).toFixed(1)} KB)`)}`);
+
+        // 5. Construct registry payload
+        const body = {
+            _id: name,
+            name,
+            'dist-tags': { latest: version },
+            versions: {
+                [version]: {
+                    ...pkgJson.data,
+                    dist: {
+                        shasum,
+                        integrity: integrityH,
+                        tarball: `${registryUrl}/${encodeURIComponent(name)}/-/${name}-${version}.tgz`,
+                    },
                 },
             },
-        },
-        _attachments: {
-            [`${name}-${version}.tgz`]: {
-                content_type: 'application/octet-stream',
-                data: tgzBase64,
-                length: tgzStat.size,
-            },
-        },
-    };
-
-    // 6. PUT to registry
-    const uploadSpinner = new Spinner('Uploading to registry...').start();
-    const { request } = require('../utils/http');
-    const bodyStr = JSON.stringify(body);
-
-    try {
-        const res = await request(`${registry}/${encodeURIComponent(name)}`, {
-            method: 'PUT',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${token}`,
-                'Content-Length': Buffer.byteLength(bodyStr),
-                ...(flags.otp ? { 'npm-otp': flags.otp } : {}),
+            _attachments: {
+                [`${name}-${version}.tgz`]: {
+                    content_type: 'application/octet-stream',
+                    data: tgzBase64,
+                    length: tgzStat.size,
+                },
             },
-            body: bodyStr,
-            retries: 1,
-        });
-
-        if (res.status < 200 || res.status >= 300) {
-            uploadSpinner.fail(`Publish failed: HTTP ${res.status} — ${res.body.slice(0, 200)}`);
-            process.exit(1);
+        };
+
+        // 6. Submit to registry
+        const uploadSpinner = new Spinner('Uploading to registry...').start();
+        const bodyStr = JSON.stringify(body);
+
+        try {
+            const res = await request(`${registryUrl}/${encodeURIComponent(name)}`, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Length': Buffer.byteLength(bodyStr),
+                    ...(flags.otp ? { 'npm-otp': flags.otp } : {}),
+                },
+                body: bodyStr,
+                retries: 1,
+            });
+
+            if (res.status < 200 || res.status >= 300) {
+                uploadSpinner.fail(`Publish failed: HTTP ${res.status} — ${res.body.slice(0, 200)}`);
+                throw new Error(`Registry responded with status ${res.status}`);
+            }
+
+            uploadSpinner.succeed('Published!');
+            this.logger.success(`\n+ ${name}@${version}`);
+            this.logger.log(this.logger.c.gray(`${registryUrl}/${encodeURIComponent(name)}`));
+        } catch (err) {
+            uploadSpinner.fail(`Publish error: ${err.message}`);
+            throw err;
         }
-
-        uploadSpinner.succeed('Published!');
-        logger.success(`\n+ ${name}@${version}`);
-        logger.log(logger.c.gray(`${registry}/${encodeURIComponent(name)}`));
-    } catch (err) {
-        uploadSpinner.fail(`Publish error: ${err.message}`);
-        process.exit(1);
     }
-};
-
-function getIgnoreList(dir) {
-    const defaults = new Set(['node_modules', '.git', '.DS_Store', '*.log', 'coverage', '.jpm-lock.json']);
-    const ignoreFile = path.join(dir, '.npmignore');
-    if (fs.existsSync(ignoreFile)) {
-        fs.readFileSync(ignoreFile, 'utf8').split('\n').forEach(l => {
-            const t = l.trim();
-            if (t && !t.startsWith('#')) defaults.add(t);
-        });
+
+    /**
+     * Generates a list of files to ignore during packing.
+     * 
+     * @param {string} dir - Project root directory
+     * @returns {Set<string>} Set of ignored patterns/filenames
+     * @private
+     */
+    _getIgnoreList(dir) {
+        const defaults = new Set(['node_modules', '.git', '.DS_Store', '*.log', 'coverage', '.jpm-lock.json']);
+        const ignoreFile = path.join(dir, '.npmignore');
+        if (fs.existsSync(ignoreFile)) {
+            fs.readFileSync(ignoreFile, 'utf8').split('\n').forEach(l => {
+                const t = l.trim();
+                if (t && !t.startsWith('#')) defaults.add(t);
+            });
+        }
+        return defaults;
     }
-    return defaults;
-}
 
-function getFilesToPack(dir, ignore) {
-    const files = [];
-    for (const entry of fs.readdirSync(dir)) {
-        if ([...ignore].some(ig => entry === ig || entry.startsWith(ig.replace('*', '')))) continue;
-        files.push(entry);
+    /**
+     * Scans the directory for files that should be included in the tarball.
+     * 
+     * @param {string} dir - Directory to scan
+     * @param {Set<string>} ignore - Set of ignored patterns
+     * @returns {string[]} List of files to pack
+     * @private
+     */
+    _getFilesToPack(dir, ignore) {
+        const files = [];
+        for (const entry of fs.readdirSync(dir)) {
+            if ([...ignore].some(ig => entry === ig || entry.startsWith(ig.replace('*', '')))) continue;
+            files.push(entry);
+        }
+        return files.length ? files : ['.'];
     }
-    return files.length ? files : ['.'];
 }
+
+module.exports = PublishCommand;
+