Introduce optional dependencies & improve pm cli arg handling

Author: webpro

packages/knip/src/binaries/package-manager/bun.ts

@@ -1,18 +1,28 @@
 import parseArgs from 'minimist';
 import type { BinaryResolver } from '../../types/config.js';
 import { isFile } from '../../util/fs.js';
-import { toEntry } from '../../util/input.js';
+import { toBinary, toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
+import { resolveX } from './bunx.js';
 
-const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'test', 'update', 'upgrade'];
+const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'test', 'update', 'upgrade', 'x'];
 
-export const resolve: BinaryResolver = (_binary, args, { manifestScriptNames, cwd, fromArgs }) => {
+export const resolve: BinaryResolver = (binary, args, options) => {
+  const bin = toBinary(binary);
   const parsed = parseArgs(args);
   const [command, script] = parsed._;
-  if (command === 'run' && manifestScriptNames.has(script)) return [];
-  if (manifestScriptNames.has(command) || commands.includes(command)) return [];
+
+  if (command === 'x') {
+    const argsForX = args.filter(arg => arg !== 'x');
+    return [bin, ...resolveX(argsForX, options)];
+  }
+
+  const { manifestScriptNames, cwd, fromArgs } = options;
+
+  if (command === 'run' && manifestScriptNames.has(script)) return [bin];
+  if (manifestScriptNames.has(command) || commands.includes(command)) return [bin];
   const filePath = command === 'run' ? script : command;
   const absFilePath = isAbsolute(filePath) ? filePath : join(cwd, filePath);
-  if (isFile(absFilePath)) return [toEntry(absFilePath)];
-  return fromArgs(args);
+  if (isFile(absFilePath)) return [bin, toEntry(absFilePath)];
+  return [bin, ...fromArgs(args)];
 };

packages/knip/src/binaries/package-manager/bunx.ts

@@ -0,0 +1,21 @@
+import parseArgs from 'minimist';
+import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.js';
+import { toBinary, toDependency } from '../../util/input.js';
+import { stripVersionFromSpecifier } from '../../util/modules.js';
+import { argsFrom } from '../util.js';
+
+export const resolveX = (args: string[], options: BinaryResolverOptions) => {
+  const { fromArgs } = options;
+  const parsed = parseArgs(args);
+  const packageSpecifier = parsed._[0];
+  const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
+  const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+  const command = parsed['shell-mode'] ? fromArgs([parsed['shell-mode']]) : [];
+  const restArgs = argsFrom(args, packageSpecifier);
+  const dependency = specifier ? [toDependency(specifier, { optional: true })] : [];
+  return [...dependency, ...packages.map(id => toDependency(id)), ...command, ...fromArgs(restArgs).slice(1)];
+};
+
+export const resolve: BinaryResolver = (_binary, args, options) => {
+  return [toBinary(_binary), ...resolveX(args, options)];
+};

packages/knip/src/binaries/package-manager/index.ts

@@ -1,13 +1,17 @@
 import * as bun from './bun.js';
+import * as bunx from './bunx.js';
 import * as npm from './npm.js';
 import * as npx from './npx.js';
 import * as pnpm from './pnpm.js';
+import * as pnpx from './pnpx.js';
 import * as yarn from './yarn.js';
 
 export default {
   bun: bun.resolve,
+  bunx: bunx.resolve,
   npm: npm.resolve,
   npx: npx.resolve,
   pnpm: pnpm.resolve,
+  pnpx: pnpx.resolve,
   yarn: yarn.resolve,
 };

packages/knip/src/binaries/package-manager/npm.ts

@@ -2,9 +2,9 @@ import parseArgs from 'minimist';
 import type { BinaryResolver } from '../../types/config.js';
 import { toBinary } from '../../util/input.js';
 
-export const resolve: BinaryResolver = (_binary, args, options) => {
+export const resolve: BinaryResolver = (binary, args, options) => {
   const { fromArgs } = options;
   const parsed = parseArgs(args);
   const [command] = parsed._;
-  return [toBinary(_binary), ...(command !== 'exec' ? [] : fromArgs(parsed._.slice(1)))];
+  return [toBinary(binary), ...(command !== 'exec' ? [] : fromArgs(parsed._.slice(1)))];
 };

packages/knip/src/binaries/package-manager/npx.ts

@@ -20,8 +20,14 @@ export const resolve: BinaryResolver = (_binary, args, options) => {
   const restArgs = argsFrom(args, packageSpecifier);
 
   const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier);
-  const dependency = isBinary ? toBinary(specifier) : toDependency(specifier);
+  const dependency = isBinary ? toBinary(specifier) : toDependency(specifier, { optional: !parsed.no });
   const specifiers = dependency && !parsed.yes ? [dependency] : [];
 
-  return [toBinary(_binary), ...specifiers, ...packages.map(toDependency), ...command, ...fromArgs(restArgs).slice(1)];
+  return [
+    toBinary(_binary),
+    ...specifiers,
+    ...packages.map(id => toDependency(id, { optional: true })),
+    ...command,
+    ...fromArgs(restArgs).slice(1),
+  ];
 };

packages/knip/src/binaries/package-manager/pnpm.ts

@@ -1,6 +1,7 @@
 import parseArgs from 'minimist';
 import type { BinaryResolver } from '../../types/config.js';
 import { toBinary } from '../../util/input.js';
+import { resolveDlx } from './pnpx.js';
 
 // https://pnpm.io/cli/add
 
@@ -56,16 +57,24 @@ const commands = [
   'why',
 ];
 
-export const resolve: BinaryResolver = (_binary, args, { manifestScriptNames, fromArgs }) => {
+export const resolve: BinaryResolver = (binary, args, options) => {
+  const bin = toBinary(binary);
   const parsed = parseArgs(args, {
     boolean: ['recursive', 'silent', 'shell-mode'],
     alias: { recursive: 'r', silent: 's', 'shell-mode': 'c' },
   });
-  const [command, binary] = parsed._;
-  if (manifestScriptNames.has(command) || commands.includes(command)) return [];
+  const [command, __binary] = parsed._;
+
+  if (command === 'dlx') {
+    const argsForDlx = args.filter(arg => arg !== 'dlx');
+    return [toBinary(binary), ...resolveDlx(argsForDlx, options)];
+  }
+
+  const { manifestScriptNames, fromArgs } = options;
+  if (manifestScriptNames.has(command) || commands.includes(command)) return [bin];
   if (command === 'exec') {
-    if (parsed._.length > 2) return [toBinary(binary), ...fromArgs(parsed._.slice(1))];
-    return [toBinary(binary)];
+    if (parsed._.length > 2) return [bin, toBinary(__binary), ...fromArgs(parsed._.slice(1))];
+    return [bin, toBinary(__binary)];
   }
-  return command ? [toBinary(command)] : [];
+  return command ? [bin, toBinary(command)] : [bin];
 };

packages/knip/src/binaries/package-manager/pnpx.ts

@@ -0,0 +1,21 @@
+import parseArgs from 'minimist';
+import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.js';
+import { toBinary, toDependency } from '../../util/input.js';
+import { stripVersionFromSpecifier } from '../../util/modules.js';
+
+export const resolveDlx = (args: string[], options: BinaryResolverOptions) => {
+  const parsed = parseArgs(args, {
+    boolean: ['silent'],
+    alias: { package: 'p', 'shell-mode': 'c' },
+  });
+  const packageSpecifier = parsed._[0];
+  const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
+  const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+  const command = parsed['shell-mode'] ? options.fromArgs([parsed['shell-mode']]) : [];
+  const dependency = specifier ? [toDependency(specifier, { optional: true })] : [];
+  return [...dependency, ...packages.map(id => toDependency(id, { optional: true })), ...command];
+};
+
+export const resolve: BinaryResolver = (_binary, args, options) => {
+  return [toBinary(_binary), ...resolveDlx(args, options)];
+};

packages/knip/src/plugins/capacitor/index.ts

@@ -22,7 +22,7 @@ const resolveConfig: ResolveConfig<CapacitorConfig> = async (config, { configFil
   const android = (await exists('android/capacitor.settings.gradle')) ? ['@capacitor/android'] : [];
   const ios = (await exists('ios/App/Podfile')) ? ['@capacitor/ios'] : [];
 
-  return [...plugins, ...android, ...ios].map(toDependency);
+  return [...plugins, ...android, ...ios].map(id => toDependency(id));
 };
 
 export default {

packages/knip/src/plugins/changesets/index.ts

@@ -22,7 +22,7 @@ const resolveConfig: ResolveConfig<ChangesetsConfig> = config => {
       : typeof config.changelog === 'string'
         ? [config.changelog]
         : []
-  ).map(toDependency);
+  ).map(id => toDependency(id));
 };
 
 export default {

packages/knip/src/plugins/commitlint/index.ts

@@ -32,7 +32,7 @@ const resolveConfig: ResolveConfig<CommitLintConfig> = async config => {
         ? [parserPreset.path ?? parserPreset]
         : []
     : [];
-  return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths].map(toDependency);
+  return [...extendsConfigs, ...plugins, ...formatter, ...parserPresetPaths].map(id => toDependency(id));
 };
 
 export default {

packages/knip/src/plugins/expo/helpers.ts

@@ -18,7 +18,7 @@ export const getDependencies = async (expoConfig: ExpoConfig, { manifest }: Plug
       })
       .filter(Boolean) as string[]) ?? [];
 
-  const inputs = new Set<Input>(pluginPackages.map(toDependency));
+  const inputs = new Set<Input>(pluginPackages.map(id => toDependency(id)));
 
   const allowedPackages = ['expo-atlas', 'expo-dev-client'];
   const allowedProductionPackages = ['expo-insights'];

packages/knip/src/plugins/gatsby/index.ts

@@ -39,7 +39,7 @@ const resolveConfig: ResolveConfig<GatsbyConfig | GatsbyNode> = async (localConf
     if (typeof _config.onCreateBabelConfig === 'function') {
       _config.onCreateBabelConfig({ actions });
     }
-    return Array.from(plugins).map(toDependency);
+    return Array.from(plugins).map(id => toDependency(id));
   }
 
   return [];

packages/knip/src/plugins/graphql-codegen/index.ts

@@ -78,7 +78,7 @@ const resolveConfig: ResolveConfig<GraphqlCodegenTypes | GraphqlConfigTypes | Gr
     .flatMap(plugin => {
       if (typeof plugin !== 'string') return [];
       if (isInternal(plugin)) return [toEntry(plugin)];
-      return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`].map(toDependency);
+      return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`].map(id => toDependency(id));
     });
 
   return [...presets, ...flatPlugins, ...nestedPlugins].map(id => (typeof id === 'string' ? toDependency(id) : id));

packages/knip/src/plugins/lefthook/index.ts

@@ -25,7 +25,7 @@ type Command = {
 const resolveConfig: ResolveConfig = async (localConfig, options) => {
   const { manifest, configFileName, cwd, getInputsFromScripts } = options;
 
-  const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(toDependency) : [];
+  const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(id => toDependency(id)) : [];
 
   if (extname(configFileName) === '.yml') {
     const scripts = findByKeyDeep<Command>(localConfig, 'run').flatMap(command => {
@@ -35,7 +35,7 @@ const resolveConfig: ResolveConfig = async (localConfig, options) => {
     });
 
     const lefthook = process.env.CI
-      ? enablers.filter(dependency => inputs.some(d => d.specifier === dependency)).map(toDependency)
+      ? enablers.filter(dependency => inputs.some(d => d.specifier === dependency)).map(id => toDependency(id))
       : [];
 
     return [...scripts, ...lefthook];

packages/knip/src/plugins/markdownlint/index.ts

@@ -23,7 +23,7 @@ const resolveConfig: ResolveConfig<MarkdownlintConfig> = (config, options) => {
   const uses = scripts
     .filter(script => script.includes('markdownlint '))
     .flatMap(script => getArgumentValues(script, / (--rules|-r)[ =]([^ ]+)/g));
-  return [...extend, ...uses].map(toDependency);
+  return [...extend, ...uses].map(id => toDependency(id));
 };
 
 export default {

packages/knip/src/plugins/nest/index.ts

@@ -15,7 +15,7 @@ const config = ['nest-cli.json', '.nestcli.json', '.nest-cli.json', 'nest.json']
 
 const resolveConfig: ResolveConfig<NestConfig> = async config => {
   const inputs = config?.collection ? [config.collection] : [];
-  return [...inputs].map(toDependency);
+  return [...inputs].map(id => toDependency(id));
 };
 
 export default {

packages/knip/src/plugins/netlify/index.ts

@@ -32,8 +32,8 @@ const resolveEntryPaths: ResolveEntryPaths<NetlifyConfig> = localConfig => {
 
 const resolveConfig: ResolveConfig<NetlifyConfig> = async localConfig => {
   return [
-    ...(localConfig?.plugins?.map(plugin => plugin.package) ?? []).map(toDependency),
-    ...extractFunctionsConfigProperty(localConfig.functions || {}, 'external_node_modules').map(toDependency),
+    ...(localConfig?.plugins?.map(plugin => plugin.package) ?? []).map(id => toDependency(id)),
+    ...extractFunctionsConfigProperty(localConfig.functions || {}, 'external_node_modules').map(id => toDependency(id)),
   ];
 };
 

packages/knip/src/plugins/npm-package-json-lint/index.ts

@@ -17,7 +17,7 @@ const packageJsonPath = 'npmpackagejsonlint';
 const config = ['package.json', ...toCosmiconfig('npmpackagejsonlint')];
 
 const resolveConfig: ResolveConfig<NpmPkgJsonLintConfig> = localConfig => {
-  return localConfig?.extends ? [localConfig.extends].map(toDependency) : [];
+  return localConfig?.extends ? [localConfig.extends].map(id => toDependency(id)) : [];
 };
 
 export default {

packages/knip/src/plugins/nx/index.ts

@@ -35,7 +35,7 @@ const findNxDependenciesInNxJson: ResolveConfig<NxConfigRoot> = async localConfi
         .map(value => value.split(':')[0])
     : [];
 
-  return compact([...targetsDefault, ...plugins, ...generators]).map(toDependency);
+  return compact([...targetsDefault, ...plugins, ...generators]).map(id => toDependency(id));
 };
 
 const resolveConfig: ResolveConfig<NxProjectConfiguration | NxConfigRoot> = async (localConfig, options) => {

packages/knip/src/plugins/oclif/index.ts

@@ -16,7 +16,7 @@ const config = ['package.json'];
 const resolveConfig: ResolveConfig<OclifConfig> = async config => {
   const plugins = config?.plugins ?? [];
   const devPlugins = config?.devPlugins ?? [];
-  return [...plugins, ...devPlugins].map(toDependency);
+  return [...plugins, ...devPlugins].map(id => toDependency(id));
 };
 
 export default {

packages/knip/src/plugins/prettier/index.ts

@@ -24,7 +24,7 @@ const resolveConfig: ResolveConfig<PrettierConfig> = config => {
   if (typeof config === 'string') return [toDeferResolve(config)];
 
   return Array.isArray(config.plugins)
-    ? config.plugins.filter((plugin): plugin is string => typeof plugin === 'string').map(toDependency)
+    ? config.plugins.filter((plugin): plugin is string => typeof plugin === 'string').map(id => toDependency(id))
     : [];
 };
 

packages/knip/src/plugins/release-it/index.ts

@@ -26,7 +26,7 @@ const resolveConfig: ResolveConfig<ReleaseItConfig> = (config, options) => {
   }
   const inputs = options.getInputsFromScripts(scripts);
 
-  return [...plugins.map(toDependency), ...inputs];
+  return [...plugins.map(id => toDependency(id)), ...inputs];
 };
 
 export default {

packages/knip/src/plugins/storybook/index.ts

@@ -44,7 +44,11 @@ const resolveConfig: ResolveConfig<StorybookConfig> = async localConfig => {
       : [builder]
     : [];
   const frameworks = localConfig.framework?.name ? [localConfig.framework.name] : [];
-  return [...addons.map(toDeferResolve), ...builderPackages.map(toDependency), ...frameworks.map(toDependency)];
+  return [
+    ...addons.map(toDeferResolve),
+    ...builderPackages.map(id => toDependency(id)),
+    ...frameworks.map(id => toDependency(id)),
+  ];
 };
 
 export default {

packages/knip/src/plugins/vitest/index.ts

@@ -45,7 +45,7 @@ const findConfigDependencies = (localConfig: ViteConfig, options: PluginOptions)
   const setupFiles = [testConfig.setupFiles ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
   const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
 
-  return [...[...environments, ...reporters, ...coverage].map(toDependency), ...setupFiles, ...globalSetup];
+  return [...[...environments, ...reporters, ...coverage].map(id => toDependency(id)), ...setupFiles, ...globalSetup];
 };
 
 const getConfigs = async (localConfig: ViteConfigOrFn | VitestWorkspaceConfig) => {

packages/knip/src/plugins/webdriver-io/index.ts

@@ -34,7 +34,7 @@ const resolveConfig: ResolveConfig<WebdriverIOConfig> = async config => {
         .map(reporter => `@wdio/${reporter}-reporter`)
     : [];
 
-  return [...frameworks, ...runners, ...reporters].map(toDependency);
+  return [...frameworks, ...runners, ...reporters].map(id => toDependency(id));
 };
 
 export default {

packages/knip/src/types/config.ts

@@ -26,7 +26,7 @@ export type GetInputsFromScriptsPartial = (
 
 type FromArgs = (args: string[]) => Input[];
 
-interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
+export interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
   fromArgs: FromArgs;
 }
 

packages/knip/src/util/get-referenced-inputs.ts

@@ -59,7 +59,7 @@ export const getReferencedInputsHandler =
 
         if (isWorkspace || isDependency(input)) {
           if (!isHandled) {
-            if ((deputy.isProduction && input.production) || !deputy.isProduction) {
+            if (!input.optional && ((deputy.isProduction && input.production) || !deputy.isProduction)) {
               // Unlisted dependency
               collector.addIssue({
                 type: 'unlisted',
@@ -93,6 +93,8 @@ export const getReferencedInputsHandler =
       return isGitIgnored(resolvedFilePath) ? undefined : resolvedFilePath;
     }
 
+    if (input.optional) return;
+
     if (!isInternal(filePath)) {
       collector.addIssue({
         type: 'unlisted',

packages/knip/src/util/input.ts

@@ -7,6 +7,7 @@ export interface Input {
   type: InputType;
   specifier: string;
   production?: boolean;
+  optional?: boolean;
   dir?: string;
   containingFilePath?: string;
 }
@@ -19,6 +20,7 @@ export interface ConfigInput extends Input {
 
 type Options = {
   production?: boolean;
+  optional?: boolean;
   dir?: string;
   containingFilePath?: string;
 };
@@ -55,7 +57,11 @@ export const toConfig = (pluginName: PluginName, specifier: string, containingFi
 
 export const isConfigPattern = (input: Input): input is ConfigInput => input.type === 'config';
 
-export const toDependency = (specifier: string): Input => ({ type: 'dependency', specifier });
+export const toDependency = (specifier: string, options: Options = {}): Input => ({
+  type: 'dependency',
+  specifier,
+  ...options,
+});
 
 export const isDependency = (input: Input) => input.type === 'dependency';
 

packages/knip/test/plugins/github-actions.test.ts

@@ -13,9 +13,6 @@ test('Find dependencies with the GitHub Actions plugin', async () => {
     cwd,
   });
 
-  assert(issues.unlisted['.github/workflows/test.yml']['@scope/retry-cli']);
-  assert(issues.unlisted['.github/workflows/test.yml']['retry-cli']);
-
   assert(issues.unresolved['.github/workflows/test.yml']['esbuild-register']);
 
   // Let's start out conservatively
@@ -37,7 +34,6 @@ test('Find dependencies with the GitHub Actions plugin', async () => {
   assert.deepEqual(counters, {
     ...baseCounters,
     binaries: 10,
-    unlisted: 2,
     unresolved: 2,
     processed: 10,
     total: 10,

packages/knip/test/util/get-inputs-from-scripts.test.ts

@@ -8,6 +8,7 @@ const cwd = resolve('fixtures/binaries');
 const containingFilePath = join(cwd, 'package.json');
 const pkgScripts = { cwd, manifestScriptNames: new Set(['program']) };
 const knownOnly = { cwd, knownBinsOnly: true };
+const optional = { optional: true };
 
 const js = toDeferResolveEntry('./script.js');
 const ts = toDeferResolveEntry('./main.ts');
@@ -132,41 +133,55 @@ test('getInputsFromScripts (npm)', () => {
 test('getInputsFromScripts (npx)', () => {
   t('npx pkg', [toBinary('npx'), toBinary('pkg')]);
   t('npx prisma migrate reset --force', [toBinary('npx'), toBinary('prisma')]);
-  t('npx @scope/pkg', [toBinary('npx'), toDependency('@scope/pkg')]);
+  t('npx @scope/pkg', [toBinary('npx'), toDependency('@scope/pkg', optional)]);
   t('npx tsx watch main', [toBinary('npx'), toBinary('tsx'), toDeferResolveEntry('main')]);
   t('npx -y pkg', [toBinary('npx')]);
   t('npx --yes pkg', [toBinary('npx')]);
   t('npx --no pkg --edit ${1}', [toBinary('npx'), toBinary('pkg')]);
   t('npx --no -- pkg --edit ${1}', [toBinary('npx'), toBinary('pkg')]);
   t('npx pkg install --with-deps', [toBinary('npx'), toBinary('pkg')]);
   t('npx pkg migrate reset --force', [toBinary('npx'), toBinary('pkg')]);
-  t('npx pkg@1.0.0 migrate reset --force', [toBinary('npx'), toDependency('pkg')]);
-  t('npx @scope/cli migrate reset --force', [toBinary('npx'), toDependency('@scope/cli')]);
+  t('npx pkg@1.0.0 migrate reset --force', [toBinary('npx'), toDependency('pkg', optional)]);
+  t('npx @scope/cli migrate reset --force', [toBinary('npx'), toDependency('@scope/cli', optional)]);
   t('npx -- pkg', [toBinary('npx'), toBinary('pkg')]);
-  t('npx -- @scope/cli@1.0.0 migrate reset --force', [toBinary('npx'), toDependency('@scope/cli')]);
-  t('npx retry-cli@0.6.0 -- curl --output /dev/null ', [toBinary('npx'), toDependency('retry-cli'), toBinary('curl')]);
-  t('npx --package pkg@0.6.0 -- curl --output /dev/null', [toBinary('npx'), toBinary('curl'), toDependency('pkg')]);
-  t('npx --package @scope/pkg@0.6.0 --package pkg -- curl', [toBinary('npx'), toBinary('curl'), toDependency('@scope/pkg'), toDependency('pkg')]);
-  t("npx --package=foo -c 'curl --output /dev/null'", [toBinary('npx'), toDependency('foo'), toBinary('curl')]);
+  t('npx -- @scope/cli@1.0.0 migrate reset --force', [toBinary('npx'), toDependency('@scope/cli', optional)]);
+  t('npx retry-cli@0.6.0 -- curl --output /dev/null ', [toBinary('npx'), toDependency('retry-cli', optional), toBinary('curl')]);
+  t('npx --package pkg@0.6.0 -- curl --output /dev/null', [toBinary('npx'), toBinary('curl'), toDependency('pkg', optional)]);
+  t('npx --package @scope/pkg@0.6.0 --package pkg -- curl', [toBinary('npx'), toBinary('curl'), toDependency('@scope/pkg', optional), toDependency('pkg', optional)]);
+  t("npx --package=foo -c 'curl --output /dev/null'", [toBinary('npx'), toDependency('foo', optional), toBinary('curl')]);
   t('npx swagger-typescript-api -p http://localhost:3030/swagger.v1.json', [toBinary('npx'), toBinary('swagger-typescript-api')]);
   t('npx swagger-typescript-api -- -p http://localhost:3030/swagger.v1.json', [toBinary('npx'), toBinary('swagger-typescript-api')]);
   t('npx tsx main', [toBinary('npx'), toBinary('tsx'), toDeferResolveEntry('main')]);
   t('npx tsx ./main.ts build', [toBinary('npx'), toBinary('tsx'), ts]);
   t('npx tsx ./main.ts -- build', [toBinary('npx'), toBinary('tsx'), ts]);
 });
 
+test('getInputsFromScripts (pnpx/pnpm dlx)', () => {
+  t('pnpx pkg', [toBinary('pnpx'), toDependency('pkg', optional)]);
+  const s = [toDependency('cowsay', optional), toDependency('lolcatjs', optional), toBinary('echo'), toBinary('cowsay'), toBinary('lolcatjs')];
+  t('pnpx --package cowsay --package lolcatjs -c \'echo "hi pnpm" | cowsay | lolcatjs\'', [toBinary('pnpx'), ...s]);
+  t('pnpm --package cowsay --package lolcatjs -c dlx \'echo "hi pnpm" | cowsay | lolcatjs\'', [toBinary('pnpm'), ...s]);
+});
+
+test('getInputsFromScripts (bunx/bun x)', () => {
+  t('bunx pkg', [toBinary('bunx'), toDependency('pkg', optional)]);
+  t('bunx cowsay "Hello world!"', [toBinary('bunx'), toDependency('cowsay', optional)]);
+  t('bunx my-cli --foo bar', [toBinary('bunx'), toDependency('my-cli', optional)]);
+  t('bun x pkg', [toBinary('bun'), toDependency('pkg', optional)]);
+});
+
 test('getInputsFromScripts (pnpm)', () => {
-  t('pnpm exec program', [toBinary('program')]);
-  t('pnpm run program', []);
-  t('pnpm program', [toBinary('program')]);
-  t('pnpm run program', [], pkgScripts);
-  t('pnpm program', [], pkgScripts);
-  t('pnpm dlx pkg', []);
-  t('pnpm --package=pkg-a dlx pkg', []);
-  t('pnpm --recursive --parallel test -- --sequence.seed=1700316221712', []);
-  t('pnpm program script.js', [], pkgScripts);
-  t('pnpm --silent program script.js', [], pkgScripts);
-  t('pnpm --silent run program script.js', [], pkgScripts);
+  t('pnpm exec program', [toBinary('pnpm'), toBinary('program')]);
+  t('pnpm run program', [toBinary('pnpm')]);
+  t('pnpm program', [toBinary('pnpm'), toBinary('program')]);
+  t('pnpm run program', [toBinary('pnpm')], pkgScripts);
+  t('pnpm program', [toBinary('pnpm')], pkgScripts);
+  t('pnpm dlx pkg', [toBinary('pnpm'), toDependency('pkg', optional)]);
+  t('pnpm --package=pkg-a dlx pkg', [toBinary('pnpm'), toDependency('pkg', optional), toDependency('pkg-a', optional)]);
+  t('pnpm --recursive --parallel test -- --sequence.seed=1700316221712', [toBinary('pnpm')]);
+  t('pnpm program script.js', [toBinary('pnpm')], pkgScripts);
+  t('pnpm --silent program script.js', [toBinary('pnpm')], pkgScripts);
+  t('pnpm --silent run program script.js', [toBinary('pnpm')], pkgScripts);
 });
 
 test('getInputsFromScripts (yarn)', () => {
@@ -229,7 +244,7 @@ test('getInputsFromScripts (bash expansion)', () => {
 
 test('getInputsFromScripts (multiline)', () => {
   t('#!/bin/sh\n. "$(dirname "$0")/_/husky.sh"\nnpx lint-staged', [toBinary('npx'), toBinary('lint-staged')]);
-  t(`for S in "s"; do\n\tnpx rc@0.6.0\n\tnpx @scope/rc@0.6.0\ndone`, [toBinary('npx'), toDependency('rc'), toBinary('npx'), toDependency('@scope/rc')]);
+  t(`for S in "s"; do\n\tnpx rc@0.6.0\n\tnpx @scope/rc@0.6.0\ndone`, [toBinary('npx'), toDependency('rc', optional), toBinary('npx'), toDependency('@scope/rc', optional)]);
 });
 
 test('getInputsFromScripts (bail outs)', () => {