nypm

nypm automatically identifies the correct package manager for a project by inspecting the directory (and parent directories) for:

1. The packageManager field in package.json.
2. The devEngines.packageManager field in package.json.
3. Presence of known lockfiles (e.g., package-lock.json, pnpm-lock.yaml, yarn.lock, etc.).

Import nypm to programmatically manage dependencies and run scripts using a unified API that works across different package managers.

// ESM import
import { addDependency } from "nypm";

// or dynamic import
const { addDependency } = await import("nypm");

Use these methods to run lifecycle scripts or download/execute packages using the project's package manager.

// Run a script defined in package.json
await runScript('test', options);

// Download and execute a package (similar to npx)
await dlx('some-package', options);

If you need the raw command strings for a specific package manager instead of executing them directly, use these command generators. They require the package manager identifier (<pm>).

// Get command to install dependencies
// Options: { short?: boolean, frozenLockFile?: boolean }
installDependenciesCommand('pnpm', { frozenLockFile: true });

// Get command to add a dependency
// Options: { dev?: boolean, global?: boolean, workspace?: boolean, yarnBerry?: boolean, short?: boolean }
addDependencyCommand('yarn', 'defu', { dev: true });

// Get command to run a script
// Options: { args?: string[] }
runScriptCommand('npm', 'build', { args: ['--production'] });

// Get command to download and execute a package (dlx)
// Options: { args?: string[], short?: boolean, packages?: string[] }
dlxCommand('bun', 'create-vite', { args: ['my-app'] });

Use these methods to manipulate project dependencies programmatically. All methods accept an options object.

// Add a regular dependency
await addDependency('defu', options);

// Add a dev dependency
await addDevDependency('defu', options);

// Remove a dependency
await removeDependency('defu', options);

// Ensure a dependency is installed
await ensureDependencyInstalled('defu', options);

// Install all project dependencies
await installDependencies(options);

// Dedupe dependencies
// Note: For bun and deno, this removes the lockfile and reinstalls all dependencies.
await dedupeDependencies(options);

You can use nypm via npx to interact with your project's package manager without needing to know which one is being used (npm, pnpm, yarn, bun, or deno).

# Install dependencies
npx nypm i

# Add a dependency
npx nypm add defu

# Remove a dependency
npx nypm remove defu

Executes a script defined in the scripts section of the package.json file using the detected package manager (e.g., npm run <name> or yarn <name>).

Options:

• name: The name of the script to run.
• cwd: The directory to run the command in.
• env: Additional environment variables to set for the execution.
• silent: Whether to run the command in silent mode.
• packageManager: The package manager info to use.
• dry: If true, the command is not executed.
• corepack: Whether to use corepack.
• args: Additional arguments to pass to the script.

import { runScript } from 'nypm';

await runScript('build', { args: ['--prod'] });

Removes one or more dependencies from the project using the appropriate package manager command (e.g., npm uninstall or yarn remove).

Options:

• name: A string or array of strings representing the package names.
• cwd: The directory to run the command in.
• silent: Whether to run the command in silent mode.
• packageManager: The package manager info to use.
• dev: Whether to remove a dev dependency.
• global: Whether to run the command in global mode.
• dry: If true, the command is not executed, but the command and arguments are returned.

import { removeDependency } from 'nypm';

await removeDependency(['lodash', 'express'], { dev: true });

Attempts to deduplicate dependencies in the project.

Behavior:

• For bun and deno, deduplication is not supported and will throw an error.
• For yarn v1, it runs yarn install.
• For other supported managers, it runs dedupe.
• If recreateLockfile is true (or if the package manager doesn't support dedupe), it deletes the existing lockfiles and runs installDependencies().

Options:

• cwd: The directory to run the command in.
• silent: Whether to run the command in silent mode.
• packageManager: The package manager info to use.
• dry: If true, the command is not executed.
• recreateLockfile: Whether to recreate the lockfile instead of deduping.

import { dedupeDependencies } from 'nypm';

await dedupeDependencies({ recreateLockfile: true });

A convenience wrapper around addDependency() that sets the dev option to true.

import { addDevDependency } from 'nypm';

await addDevDependency('typescript', { cwd: './' });