jpm-pkg 1.0.3 → 1.0.5

package/src/commands/init.js

@@ -3,86 +3,131 @@
 const readline = require('node:readline');
 const path = require('node:path');
 const os = require('node:os');
+const BaseCommand = require('./base-command');
 const PackageJSON = require('../core/package-json');
-const logger = require('../utils/logger');
 
-module.exports = async function init(args, flags) {
-    const cwd = process.cwd();
-    const pkgFile = path.join(cwd, 'package.json');
-    const pkg = new PackageJSON(pkgFile);
-
-    if (flags.y || flags.yes) {
-        // Non-interactive: write defaults
-        pkg.save();
-        logger.success(`Created package.json`);
-        return;
+/**
+ * InitCommand handles the 'jpm init' and 'jpm setup' commands.
+ * It initializes a new package.json file, either interactively or with defaults.
+ */
+class InitCommand extends BaseCommand {
+    constructor() {
+        super('init');
     }
 
-    logger.section('JPM Init — create a new package.json');
-    logger.log(logger.c.gray('Press Enter to accept defaults shown in parentheses.\n'));
-
-    const existing = pkg.data;
-
-    const answers = await prompt([
-        { key: 'name', label: 'Package name', default: existing.name || path.basename(cwd) },
-        { key: 'version', label: 'Version', default: existing.version || '1.0.0' },
-        { key: 'description', label: 'Description', default: existing.description || '' },
-        { key: 'main', label: 'Entry point', default: existing.main || 'index.js' },
-        { key: 'author', label: 'Author', default: existing.author || os.userInfo().username },
-        { key: 'license', label: 'License', default: existing.license || 'MIT' },
-    ]);
-
-    const data = {
-        name: answers.name,
-        version: answers.version,
-        description: answers.description,
-        main: answers.main,
-        scripts: existing.scripts || { test: 'echo "Error: no test specified" && exit 1' },
-        keywords: existing.keywords || [],
-        author: answers.author,
-        license: answers.license,
-        dependencies: existing.dependencies || {},
-        devDependencies: existing.devDependencies || {},
-    };
-
-    // Strip empty strings from output
-    for (const [k, v] of Object.entries(data)) {
-        if (v === '') delete data[k];
+    /**
+     * Executes the initialization process.
+     * 
+     * @param {string[]} args - Optional arguments
+     * @param {Object} flags - CLI flags (e.g., -y for defaults)
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const cwd = process.cwd();
+        const pkgFile = path.join(cwd, 'package.json');
+        const pkg = new PackageJSON(pkgFile);
+
+        if (flags.y || flags.yes) {
+            // Non-interactive: write defaults immediately
+            pkg.save();
+            this.logger.success(`Created package.json`);
+            return;
+        }
+
+        this.logger.section('JPM Init — create a new package.json');
+        this.logger.log(this.logger.c.gray('Press Enter to accept defaults shown in parentheses.\n'));
+
+        const existing = pkg.data;
+
+        const answers = await this._prompt([
+            { key: 'name', label: 'Package name', default: existing.name || path.basename(cwd) },
+            { key: 'version', label: 'Version', default: existing.version || '1.0.0' },
+            { key: 'description', label: 'Description', default: existing.description || '' },
+            { key: 'main', label: 'Entry point', default: existing.main || 'index.js' },
+            { key: 'author', label: 'Author', default: existing.author || os.userInfo().username },
+            { key: 'license', label: 'License', default: existing.license || 'MIT' },
+        ]);
+
+        const data = {
+            name: answers.name,
+            version: answers.version,
+            description: answers.description,
+            main: answers.main,
+            scripts: existing.scripts || { test: 'echo "Error: no test specified" && exit 1' },
+            keywords: existing.keywords || [],
+            author: answers.author,
+            license: answers.license,
+            dependencies: existing.dependencies || {},
+            devDependencies: existing.devDependencies || {},
+        };
+
+        // Strip empty strings from output to keep it clean
+        for (const [k, v] of Object.entries(data)) {
+            if (v === '') delete data[k];
+        }
+
+        this.logger.log('\n' + JSON.stringify(data, null, 2));
+        const confirm = await this._ask('\nIs this OK? (yes) ');
+
+        if (confirm.toLowerCase() === 'no' || confirm.toLowerCase() === 'n') {
+            this.logger.warn('Aborted.');
+            return;
+        }
+
+        for (const [k, v] of Object.entries(data)) {
+            pkg.setField(k, v);
+        }
+
+        pkg.save();
+        this.logger.success(`\nWrote to ${pkgFile}`);
     }
 
-    logger.log('\n' + JSON.stringify(data, null, 2));
-    const confirm = await ask('\nIs this OK? (yes) ');
-    if (confirm === 'no' || confirm === 'n') {
-        logger.warn('Aborted.');
-        return;
+    /**
+     * Internal helper to prompt for multiple fields sequentially via terminal.
+     * 
+     * @param {Object[]} fields - Field definitions to prompt for
+     * @returns {Promise<Object>} Map of field keys to user answers
+     * @private
+     */
+    _prompt(fields) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answers = {};
+        return new Promise(resolve => {
+            let i = 0;
+            const next = () => {
+                if (i >= fields.length) {
+                    rl.close();
+                    resolve(answers);
+                    return;
+                }
+                const f = fields[i++];
+                const label = this.logger.c.cyan(f.label) + (f.default ? this.logger.c.gray(` (${f.default})`) : '') + ': ';
+                rl.question(label, (val) => {
+                    answers[f.key] = val.trim() || f.default || '';
+                    next();
+                });
+            };
+            next();
+        });
     }
 
-    for (const [k, v] of Object.entries(data)) pkg.setField(k, v);
-    pkg.save();
-    logger.success(`\nWrote to ${pkgFile}`);
-};
-
-function prompt(fields) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const answers = {};
-    return new Promise(resolve => {
-        let i = 0;
-        function next() {
-            if (i >= fields.length) { rl.close(); resolve(answers); return; }
-            const f = fields[i++];
-            const label = logger.c.cyan(f.label) + (f.default ? logger.c.gray(` (${f.default})`) : '') + ': ';
-            rl.question(label, (val) => {
-                answers[f.key] = val.trim() || f.default || '';
-                next();
+    /**
+     * Internal helper to ask a single question via terminal.
+     * 
+     * @param {string} label - Question text
+     * @returns {Promise<string>} Trimmed user response
+     * @private
+     */
+    _ask(label) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise(resolve => {
+            rl.question(this.logger.c.cyan(label), (val) => {
+                rl.close();
+                resolve(val.trim());
             });
-        }
-        next();
-    });
+        });
+    }
 }
 
-function ask(label) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    return new Promise(resolve => {
-        rl.question(logger.c.cyan(label), (val) => { rl.close(); resolve(val.trim()); });
-    });
-}
+module.exports = InitCommand;
+

package/src/commands/install.js

@@ -1,139 +1,148 @@
 'use strict';
 
+const BaseCommand = require('./base-command');
 const Resolver = require('../core/resolver');
 const Installer = require('../core/installer');
 const Lockfile = require('../core/lockfile');
 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');
-const config = require('../utils/config');
 
 /**
- * Command handler for 'jpm install' (and its aliases 'get', 'add', 'syn').
- * Orchestrates package resolution, downloading, and filesystem installation.
- * 
- * @param {string[]} args - Positional arguments (package names/versions)
- * @param {Object} flags - CLI flags (e.g., --save-dev, --fast)
- * @returns {Promise<void>}
+ * InstallCommand handles the 'jpm install' command and its aliases.
+ * It coordinates package resolution, downloading, and filesystem installation.
  */
-module.exports = async function install(args, flags) {
-    const cwd = process.cwd();
-    const pkgJson = PackageJSON.fromDir(cwd);
-    const lockfile = new Lockfile(cwd);
-    const isDev = flags.D || flags['save-dev'];
-    const isExact = flags.E || flags['save-exact'] || config.saveExact;
-    const noSave = flags['no-save'];
-    const dryRun = flags['dry-run'];
-
-    // ── Parse packages to install ──────────────────────────────────────────────
-    let toInstall = [];
-
-    if (args.length) {
-        // `jpm install express lodash@4.17.21 @types/node`
-        for (const arg of args) {
-            const lastAt = arg.lastIndexOf('@');
-            const hasVersion = lastAt > 0;
-            const name = hasVersion ? arg.slice(0, lastAt) : arg;
-            const version = hasVersion ? arg.slice(lastAt + 1) : 'latest';
-            toInstall.push({ name, version });
+class InstallCommand extends BaseCommand {
+    constructor() {
+        super('install');
+    }
+
+    /**
+     * Executes the installation process.
+     * 
+     * @param {string[]} args - Positional arguments (package names/versions)
+     * @param {Object} flags - CLI flags (e.g., --save-dev, --fast)
+     * @returns {Promise<void>}
+     */
+    async run(args, flags) {
+        const cwd = process.cwd();
+        const pkgJson = PackageJSON.fromDir(cwd);
+        const lockfile = new Lockfile(cwd);
+        const isDev = flags.D || flags['save-dev'];
+        const isExact = flags.E || flags['save-exact'] || this.config.saveExact;
+        const noSave = flags['no-save'];
+        const dryRun = flags['dry-run'];
+
+        // ── Parse packages to install ──────────────────────────────────────────────
+        let toInstall = [];
+
+        if (args.length) {
+            // Specific packages requested: `jpm install express lodash@4.17.21`
+            for (const arg of args) {
+                const lastAt = arg.lastIndexOf('@');
+                const hasVersion = lastAt > 0;
+                const name = hasVersion ? arg.slice(0, lastAt) : arg;
+                const version = hasVersion ? arg.slice(lastAt + 1) : 'latest';
+                toInstall.push({ name, version });
+            }
+        } else {
+            // General install from package.json
+            const spinner = new Spinner('Reading package.json...').start();
+            const allDeps = {
+                ...pkgJson.dependencies,
+                ...(flags.production ? {} : pkgJson.devDependencies),
+            };
+            spinner.succeed(`Found ${Object.keys(allDeps).length} dependencies`);
+
+            // Deterministic install from lockfile if it exists and no arguments provided
+            if (lockfile.exists()) {
+                this.logger.info('Using lock file for deterministic install');
+                const lockData = lockfile.allPackages();
+                const installer = new Installer(cwd);
+                const bar = new Spinner('Installing from lock file...');
+                bar.start();
+                const fakeMap = new Map(lockData.map(p => [`${p.name}@${p.version}`, p]));
+                await installer.installAll(fakeMap, { dryRun, flags });
+                bar.succeed(`Installed ${lockData.length} packages`);
+                return;
+            }
+
+            toInstall = Object.entries(allDeps).map(([name, version]) => ({ name, version }));
         }
-    } else {
-        const spinner = new Spinner('Reading package.json...').start();
-        const allDeps = {
-            ...pkgJson.dependencies,
-            ...(flags.production ? {} : pkgJson.devDependencies),
-        };
-        spinner.succeed(`Found ${Object.keys(allDeps).length} dependencies`);
-
-        // Prioritize lockfile-based installation for deterministic results
-        if (lockfile.exists()) {
-            logger.info('Using lock file for deterministic install');
-            const lockData = lockfile.allPackages();
-            const installer = new Installer(cwd);
-            const bar = new (require('../utils/progress').Spinner)('Installing from lock file...');
-            bar.start();
-            const fakeMap = new Map(lockData.map(p => [`${p.name}@${p.version}`, p]));
-            await installer.installAll(fakeMap, { dryRun, flags });
-            bar.succeed(`Installed ${lockData.length} packages`);
+
+        if (!toInstall.length) {
+            this.logger.info('Nothing to install.');
             return;
         }
 
-        toInstall = Object.entries(allDeps).map(([name, version]) => ({ name, version }));
-    }
+        // ── Resolve ────────────────────────────────────────────────────────────────
+        const resolveSpinner = new Spinner(`Resolving ${toInstall.length} package(s)...`).start();
+        const resolver = new Resolver();
 
-    if (!toInstall.length) {
-        logger.info('Nothing to install.');
-        return;
-    }
+        const deps = {};
+        const devDeps = {};
+        for (const { name, version } of toInstall) {
+            if (isDev) devDeps[name] = version;
+            else deps[name] = version;
+        }
 
-    // ── Resolve ────────────────────────────────────────────────────────────────
-    const resolveSpinner = new Spinner(`Resolving ${toInstall.length} package(s)...`).start();
-    const resolver = new Resolver();
+        let resolvedMap;
+        try {
+            resolvedMap = await resolver.resolve(deps, devDeps, {}, (count, total) => {
+                resolveSpinner.text = `Resolving packages... (${count} resolved)`;
+            });
+            resolveSpinner.succeed(`Resolved ${resolvedMap.size} packages (including transitive deps)`);
+        } catch (err) {
+            resolveSpinner.fail(`Resolution failed: ${err.message}`);
+            throw err; // Let caller handle exit
+        }
 
-    const deps = {};
-    const devDeps = {};
-    for (const { name, version } of toInstall) {
-        if (isDev) devDeps[name] = version;
-        else deps[name] = version;
-    }
+        // Warn about circular deps
+        const circular = resolver.findCircular();
+        if (circular.length) {
+            this.logger.warn(`Circular dependencies detected:\n  ${circular.join('\n  ')}`);
+        }
 
-    let resolvedMap;
-    try {
-        resolvedMap = await resolver.resolve(deps, devDeps, {}, (count, total) => {
-            resolveSpinner.text = `Resolving packages... (${count} resolved)`;
-        });
-        resolveSpinner.succeed(`Resolved ${resolvedMap.size} packages (including transitive deps)`);
-    } catch (err) {
-        resolveSpinner.fail(`Resolution failed: ${err.message}`);
-        process.exit(1);
-    }
+        // ── Install ────────────────────────────────────────────────────────────────
+        this.logger.info(`Installing ${resolvedMap.size} packages...`);
+        const installer = new Installer(cwd);
+        try {
+            await installer.installAll(resolvedMap, { dryRun, flags });
+        } catch (err) {
+            this.logger.error(`Install failed: ${err.message}`);
+            throw err;
+        }
 
-    // Warn about circular deps
-    const circular = resolver.findCircular();
-    if (circular.length) {
-        logger.warn(`Circular dependencies detected:\n  ${circular.join('\n  ')}`);
-    }
+        // ── Update package.json & lock file ─────────────────────────────────────────
+        if (!noSave && !dryRun && args.length) {
+            for (const { name } of toInstall) {
+                const resolved = [...resolvedMap.values()].find(m => m.name === name);
+                if (!resolved) continue;
+                pkgJson.addDependency(name, resolved.version, { dev: !!isDev, exact: isExact });
+            }
+            pkgJson.save();
+            this.logger.verbose('Updated package.json');
+        }
 
-    // ── Install ────────────────────────────────────────────────────────────────
-    logger.info(`Installing ${resolvedMap.size} packages...`);
-    const installer = new Installer(cwd);
-    try {
-        await installer.installAll(resolvedMap, { dryRun, flags });
-    } catch (err) {
-        logger.error(`Install failed: ${err.message}`);
-        process.exit(1);
-    }
+        if (!dryRun) {
+            lockfile.update(resolvedMap).save();
+            this.logger.verbose('Updated jpm-lock.json');
+        }
 
-    // ── Update package.json & lock file ─────────────────────────────────────────
-    if (!noSave && !dryRun && args.length) {
-        for (const { name } of toInstall) {
-            // Find actual resolved version
-            const resolved = [...resolvedMap.values()].find(m => m.name === name);
-            if (!resolved) continue;
-            pkgJson.addDependency(name, resolved.version, { dev: !!isDev, exact: isExact });
+        // ── Summary ────────────────────────────────────────────────────────────────
+        const dupes = resolver.deduplicate();
+        if (dupes.length) {
+            this.logger.verbose(`Deduplication: ${dupes.length} packages have multiple versions`);
         }
-        pkgJson.save();
-        logger.verbose('Updated package.json');
-    }
 
-    if (!dryRun) {
-        lockfile.update(resolvedMap).save();
-        logger.verbose('Updated jpm-lock.json');
-    }
+        const directly = toInstall.map(({ name }) => {
+            const r = [...resolvedMap.values()].find(m => m.name === name);
+            return r ? `${r.name}@${r.version}` : name;
+        });
 
-    // ── Summary ────────────────────────────────────────────────────────────────
-    const dupes = resolver.deduplicate();
-    if (dupes.length) {
-        logger.verbose(`Deduplication: ${dupes.length} packages have multiple versions`);
+        this.logger.success(`\nadded ${resolvedMap.size} packages`);
+        directly.forEach(p => this.logger.log(`  + ${this.logger.c.green(p)}`));
     }
+}
 
-    const directly = toInstall.map(({ name }) => {
-        const r = [...resolvedMap.values()].find(m => m.name === name);
-        return r ? `${r.name}@${r.version}` : name;
-    });
+module.exports = InstallCommand;
 
-    logger.success(`\nadded ${resolvedMap.size} packages`);
-    directly.forEach(p => logger.log(`  + ${logger.c.green(p)}`));
-};