prod-files 0.1.3 → 0.2.0

package/README.md

@@ -11,7 +11,7 @@ projects, or you’re just obsessed with small deployments.
 
 It's relatively fast, prunes
 [Sentry's `node_modules`](https://github.com/getsentry/sentry/blob/master/package.json)
-in 2.1s (M2 MacBook). Prod deps only though, installed with `pnpm i --prod`, but
+in 1.8s (M2 MacBook). Prod deps only though, installed with `pnpm i --prod`, but
 that's the common use-case anyway.
 
 ## Install
@@ -36,8 +36,7 @@ Examples:
   arguments, so don't use equals signs:
   $ pf -i "**/foo" -e "**/*tsconfig*.json" node_modules/.pnpm
 
-  Also with short-hand args the space between the key and the value can be
-  omitted:
+  In short-hand args the space between the key and the value can be omitted:
   $ pf -i"**/foo" node_modules/.pnpm
 
 Usage:
@@ -51,18 +50,24 @@ Arguments:
                 - yarn: 'node_modules' or 'node_modules/.store'
 
 Flags:
-  -i, --include Glob patterns of extra files to be removed. Uses node's
-                path.matchesGlob(), with one exception: patterns ending with
-                slash '**/foo/' are marked as directories.
+  -i, --include Extra custom glob pattern. Uses node's path.matchesGlob(),
+                with one exception: patterns ending with slash '**/foo/' are
+                marked as directories. Can have multiple.
 
   -e, --exclude Exclude existing glob patterns if the script is too
-                aggressive. Must be exact match.
+                aggressive. Must be exact match. Can have multiple.
+
+  -d, --dryRun  Nothing is removed and the paths are printed out.
 
   -h, --help    Prints out the help.
 
-  -g, --globs   Prints out the default globs.
+  -g, --showGlobs
+                Prints out the default globs.
+
+  --noGlobs     Disable default glob patterns, only use patterns from
+                --include.
 
-  -n, --noSize  Skips the size calc at the end, saves about 200-1000ms.
+  -n, --noSize  Skips the size calculation.
 
   -q, --quiet   Quiet output, suppresses stdout.
 ```
@@ -88,6 +93,43 @@ Different package manager `node_modules` paths:
 | yarn    | pnpm         | `node_modules/.store` | same as pnpm    |
 | yarn    | pnp          | no-op                 | no node_modules |
 
+### Provide your own globs
+
+The default globs can de disabled with `--noGlobs` flag, and only globs in
+`--include` are matched:
+
+```sh
+pnpm prod-files --noGlobs -i "**/custom/" -i "**/*.html" node_modules/.pnpm
+```
+
+### Dy run
+
+The `--dry-run` flag does not delete anything and prints out the paths:
+
+```sh
+pnpm prod-files --dryRun node_modules/.pnpm
+```
+
+### Use as a search
+
+You can use `prod-files` to search any dir if you set `--dryRun` and
+`--noGlobs`, and provide the search term in `--include`:
+
+```sh
+pnpm prod-files --noGlobs --dryRun --include="**/bower.json" node_modules/.pnpm
+
+Pruning (--dryRun, nothing deleted): node_modules/.pnpm
+node_modules/.pnpm/less@4.3.0/node_modules/less/bower.json
+node_modules/.pnpm/papaparse@5.5.3/node_modules/papaparse/bower.json
+node_modules/.pnpm/reflux@0.4.1_react@19.2.3/node_modules/reflux/bower.json
+node_modules/.pnpm/sprintf-js@1.0.3/node_modules/sprintf-js/bower.json
+```
+
+Sentry's `node_modules` has 4 bower config files :)
+
+> [!CAUTION]\
+> You're wielding `rm -rf` here, always remember to set `--dryRun`!
+
 ### Dockerfile example
 
 Simple yet somewhat realistic example usage in Dockerfile for an app named `foo`
@@ -101,25 +143,27 @@ RUN pnpm fetch
 COPY . ./
 RUN pnpm i --offline --frozen-lockfile
 RUN pnpm build
-RUN pnpm -F=foo --prod deploy /my-app/foo
-# Run it as the last command of the build step. NOTE: if you installed with
-# --prod flag, prod-files needs to be a prod dep. Or use pnpx/npx/yarn dlx
-RUN pnpm prod-files my-app/foo/node_modules/.pnpm
+RUN pnpm -F=foo --prod deploy /foo
+# Run it as the last command of the build step.
+# NOTE: with --prod, the script needs to be a prod dep. Or use pnpx/npx/yarn dlx
+WORKDIR /foo
+RUN pnpm prod-files node_modules/.pnpm --noSize
 
 # Enjoy your new slimmer image
 FROM node:lts-alpine3.19 AS foo
-COPY --from=base /my-app/foo /my-app/foo
-WORKDIR /myapp/foo
+COPY --from=base foo/build /foo/build
+COPY --from=base foo/node_modules /foo/node_modules
+WORKDIR /foo
 CMD node build/server.js
 ```
 
-Or use wget in if you don't have a package manager in your env (there are
-certain risks involved when you execute files downloaded from the net, if I get
+Or use `wget` if you don't have a package manager in your env (there are certain
+risks involved when you execute files downloaded from the net, if I get
 comprised that file can have anything):
 
 ```dockerfile
-RUN wget -O pf.js https://raw.githubusercontent.com/hilja/prod-files/refs/heads/main/index.mjs
-RUN node pf.js my-app/foo/node_modules/.pnpm
+RUN wget -O pf.mjs https://raw.githubusercontent.com/hilja/prod-files/refs/heads/main/index.mjs
+RUN node pf.mjs /foo/node_modules/.pnpm
 ```
 
 ## Development
@@ -138,23 +182,29 @@ pnpm test
 
 ### End to end tests
 
-In `test-project` directory has Sentry's `package.json`. You can run the script
-against it to see how it fairs in real-world use and get some timing data.
+The `test-project` directory has Sentry's `package.json`. You can run the script
+against it to see how it does in real-world use and get some timing data.
 
 ```sh
 # Re-installs the packages and runs the script on it
 pnpm test:e2e
-# Disable size reportings since it's pretty slow
+# Disable size reportings since it adds 200-300ms
 pnpm test:e2e --noSize
 ```
 
-The nuke command removes `node_modules` and prunes the store:
+If you're testing `--dryRun`, use `test:e2e:run`, it does not reinstall:
+
+```sh
+pnpm test:r2e:run
+```
+
+The nuke command removes `test-project/node_modules` and prunes the store:
 
 ```sh
 pnpm test:e2e:nuke
 ```
 
-There's also a simple script to print the weight of `test-project/node_modules/`
+There's also a simple script to print the weight of `test-project/node_modules`
 using `du`. You can run it before and after to see more detailed results:
 
 ```sh

package/index.mjs

@@ -1,7 +1,7 @@
 // oxlint-disable prefer-spread
 import cp from 'node:child_process'
 import fs from 'node:fs/promises'
-import { matchesGlob, join, isAbsolute, resolve, dirname } from 'node:path'
+import { matchesGlob, join, isAbsolute, resolve } from 'node:path'
 import { parseArgs, promisify, styleText } from 'node:util'
 
 const exec = promisify(cp.exec)
@@ -21,13 +21,16 @@ const defaultGlobs = [
   '**/*.md',
   '**/*.map',
   '**/*.{,m,c}ts',
-  '**/*.tsx',
+  '**/*.{j,t}sx',
   '**/doc{,s}/',
 
   // Types
   '**/*tsconfig*.json',
   '**/*.tsbuildinfo',
   '**/flow-typed/',
+  '**/.flowconfig',
+  '**/*.flow',
+  '**/__typings__/',
 
   // Sensitive
   '**/.env*',
@@ -39,6 +42,8 @@ const defaultGlobs = [
   '**/yarn.lock',
   '**/bun.lock',
   '**/bunfig.toml',
+  '**/bower.json',
+  '**/node_modules/.bin/',
 
   // IDE
   '**/.idea/',
@@ -54,6 +59,7 @@ const defaultGlobs = [
   '**/contributing',
   '**/CONTRIBUTORS',
   '**/contributors',
+  '**/node_modules/**/man/',
 
   // CI/CD
   '**/.github/',
@@ -69,6 +75,7 @@ const defaultGlobs = [
   // Tests
   '**/test{,s}/',
   '**/spec{,s}/',
+  '**/**.{test,spec}.{js,mjs}',
   '**/__{mocks,tests}__/',
   '**/jest.*.{js,ts}',
   '**/vitest.*.ts',
@@ -77,6 +84,8 @@ const defaultGlobs = [
   '**/wallaby.{js,ts}',
   '**/playwright.config.{js,ts}',
   '**/.mocharc*',
+  '**/.zuul.yml',
+  '**/.coveralls.yml',
 
   // Build/bundle config
   '**/{rollup,rolldown,vite}.config.{js,ts,mjs}',
@@ -100,8 +109,9 @@ const defaultGlobs = [
   '**/*.png',
 
   // Linters and formatters
-  '**/eslint*.{json,jsonc,ts}',
-  '**/.eslintrc',
+  '**/eslint*.{json,jsonc,ts,js,mjs}',
+  '**/.eslintrc*',
+  '**/.eslintignore',
   '**/prettier.config*',
   '**/.prettier*',
   '**/.ox{lint,fmt}rc.json{,c}',
@@ -149,6 +159,11 @@ const defaultGlobs = [
   '**/*.coffee',
 
   // Misc
+  '**/KEYS',
+  '**/.spmignore',
+  '**/.editorconfig',
+  '**/component.json',
+  '**/*.jison',
   '**/.jscpd',
   '**/*.jst',
   '**/*.log',
@@ -189,8 +204,7 @@ function usage() {
     arguments, so don't use equals signs:
     $ pf -i "**/foo" -e "**/*tsconfig*.json" node_modules/.pnpm
 
-    Also with short-hand args the space between the key and the value can be
-    omitted:
+    In short-hand args the space between the key and the value can be omitted:
     $ pf -i"**/foo" node_modules/.pnpm
 
   Usage:
@@ -204,18 +218,24 @@ function usage() {
                   - yarn: 'node_modules' or 'node_modules/.store'
 
   Flags:
-    -i, --include Glob patterns of extra files to be removed. Uses node's
-                  path.matchesGlob(), with one exception: patterns ending with
-                  slash '**/foo/' are marked as directories.
+    -i, --include Extra custom glob pattern. Uses node's path.matchesGlob(),
+                  with one exception: patterns ending with slash '**/foo/' are
+                  marked as directories. Can have multiple.
 
     -e, --exclude Exclude existing glob patterns if the script is too
-                  aggressive. Must be exact match.
+                  aggressive. Must be exact match. Can have multiple.
+
+    -d, --dryRun  Nothing is removed and the paths are printed out.
 
     -h, --help    Prints out the help.
 
-    -g, --globs   Prints out the default globs.
+    -g, --showGlobs
+                  Prints out the default globs.
+
+    --noGlobs     Disable default glob patterns, only use patterns from
+                  --include.
 
-    -n, --noSize  Skips the size calc at the end, saves about 200-1000ms.
+    -n, --noSize  Skips the size calculation.
 
     -q, --quiet   Quiet output, suppresses stdout.
 `
@@ -264,8 +284,7 @@ const style = (color, args) => args.map(a => styleText(color, String(a)))
  * @type {Logger}
  */
 export const log = {
-  error: (...a) =>
-    quiet ? undefined : console.error.apply(console, style('red', a)),
+  error: (...a) => console.error.apply(console, style('red', a)),
   info: (...a) =>
     quiet ? undefined : console.info.apply(console, style('blue', a)),
   log: (...a) => (quiet ? undefined : console.log.apply(console, a)),
@@ -275,8 +294,8 @@ export const log = {
 }
 
 /**
- * Get size of node_modules
- * @param {string} dirPath - Path to node_modules
+ * Get disk usage via du (512-byte blocks)
+ * @param {string} dirPath
  * @returns {Promise<number>}
  */
 async function getSize(dirPath) {
@@ -286,14 +305,36 @@ async function getSize(dirPath) {
   return size ? Number.parseInt(size, 10) : 0
 }
 
+/**
+ * Sums disk usage of a path using lstat blocks (512-byte blocks, same as du)
+ * @param {string} path
+ * @returns {Promise<number>} Total in 512-byte blocks
+ */
+async function treeSize(path) {
+  /** @type {import('node:fs').Stats} */
+  let stat
+  try {
+    stat = await fs.lstat(path)
+  } catch {
+    // Entry disappeared (concurrent pruning), count as 0
+    return 0
+  }
+  if (!stat.isDirectory()) return stat.blocks
+  const names = await fs.readdir(path).catch(() => [])
+  const sizes = await Promise.all(names.map(n => treeSize(join(path, n))))
+  let total = 0
+  for (const s of sizes) total += s
+  return total
+}
+
 /**
  * @param {number} originalSize
  * @param {number} prunedSize
  */
-function calcSize(originalSize, prunedSize) {
+export function calcSize(originalSize, prunedSize) {
   const diff = originalSize - prunedSize
   const diffMb = `${(diff / 1024).toFixed(1)} MB`
-  const diffPercent = `${((diff / prunedSize) * 100).toFixed(1)}%`
+  const diffPercent = `${((diff / originalSize) * 100).toFixed(1)}%`
 
   return `${diffPercent} (${diffMb})`
 }
@@ -301,25 +342,23 @@ function calcSize(originalSize, prunedSize) {
 /**
  * Prints a nice diff table
  * @param {object} opts
- * @param {Promise<number> | undefined} opts.prunedSize
+ * @param {number | undefined} opts.removedBytes
  * @param {number} opts.startTime
  * @param {number} opts.itemCount
- * @param {Promise<number> | undefined} opts.originalSize
+ * @param {number | undefined} opts.originalSize
  */
-export async function printDiff({
-  prunedSize,
+export function printDiff({
+  removedBytes,
   startTime,
   itemCount,
   originalSize,
 }) {
-  const [original, pruned] =
-    originalSize && prunedSize
-      ? await Promise.all([originalSize, prunedSize])
-      : [undefined, undefined]
-
   log.table([
     {
-      ...(original && pruned && { Pruned: calcSize(original, pruned) }),
+      ...(originalSize &&
+        removedBytes && {
+          Pruned: calcSize(originalSize, originalSize - removedBytes),
+        }),
       Time: `${((Date.now() - startTime) / 1000).toFixed(1)}s`,
       Items: itemCount,
     },
@@ -332,9 +371,11 @@ export async function printDiff({
  * @property {string} [path] - Path to node_modules
  * @property {string[]} include - New glob pattern
  * @property {string[]} exclude - Existing glob pattern
+ * @property {boolean} dryRun - Print out the files to be removed, no deletion
  * @property {boolean} help - Prints help
+ * @property {boolean} showGlobs - Prints globs
+ * @property {boolean} noGlobs - Disable default glob patterns
  * @property {boolean} noSize - Don't show size savings
- * @property {boolean} globs - Prints globs
  * @property {boolean} quiet - Suppress console.log output
  */
 
@@ -342,7 +383,6 @@ export async function printDiff({
  * Parse the command-line arguments into an object
  * @returns {Args}
  */
-
 function handleArgs() {
   try {
     const {
@@ -353,8 +393,10 @@ function handleArgs() {
       options: {
         include: { type: 'string', short: 'i', default: [], multiple: true },
         exclude: { type: 'string', short: 'e', default: [], multiple: true },
+        dryRun: { type: 'boolean', short: 'd', default: false },
         help: { type: 'boolean', short: 'h', default: false },
-        globs: { type: 'boolean', short: 'g', default: false },
+        showGlobs: { type: 'boolean', short: 'g', default: false },
+        noGlobs: { type: 'boolean', default: false },
         noSize: { type: 'boolean', short: 'n', default: false },
         quiet: { type: 'boolean', short: 'q', default: false },
       },
@@ -666,160 +708,144 @@ export function findJunkFiles(files, compiledGlobs = defaultCompiledGlobs) {
 }
 
 /**
- * Removes descendant paths when an ancestor path is already present
- * @param {string[]} paths - Paths to compact
- * @returns {string[]} A sorted list without redundant child paths
+ * @typedef {object} WalkResult
+ * @property {string[]} removed - Compacted list of removed paths
+ * @property {number} removedBlocks - Removed disk usage in 512-byte blocks
+ */
+
+/**
+ * Parallel walker that finds junk, removes it, and cleans empty dirs in one
+ * pass. Skips recursing into junk directories (implicit path compacting) and
+ * removes empty ancestors bottom-up as the recursion unwinds.
+ * @param {CompiledGlobs} compiledGlobs - Precompiled glob matchers
+ * @param {ArgsWithPath} opts - The args object
+ * @returns {Promise<WalkResult>}
  */
-export function compactPaths(paths) {
-  /** @type {Set<string>} */
-  const seen = new Set()
+async function walkAndPrune(compiledGlobs, opts) {
   /** @type {string[]} */
-  const compact = []
+  const removed = []
+  let removedBlocks = 0
+  const hasAnyGlobs = compiledGlobs.any.globs.length > 0
+  const hasDirGlobs = compiledGlobs.dir.globs.length > 0
+
+  /**
+   * Walks a directory in parallel, removes junk, and reports whether the
+   * directory still has content so the caller can clean up empty parents
+   * @param {string} dir
+   * @returns {Promise<boolean>} true when the directory still has content
+   */
+  async function walkDir(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true })
+
+    /** @type {string[]} */
+    const junkPaths = []
+    /** @type {string[]} */
+    const keptDirPaths = []
+    let keptFiles = 0
+
+    for (const entry of entries) {
+      const { name } = entry
+      const isDir = entry.isDirectory()
+      const path = join(dir, name)
+
+      // Basename checks are cheapest, try them first
+      if (
+        matchesSet(name, compiledGlobs.any) ||
+        (isDir && matchesSet(name, compiledGlobs.dir))
+      ) {
+        junkPaths.push(path)
+        continue
+      }
 
-  // Sorting guarantees parents are encountered before their nested children
-  for (const path of paths.toSorted()) {
-    let i = path.lastIndexOf('/')
+      // Full path glob checks only when compiled globs exist
+      if (hasAnyGlobs || (isDir && hasDirGlobs)) {
+        const escapedPath = escapeLeadingDots(isDir ? `${path}/` : path)
+        if (
+          compiledGlobs.any.globs.some(g => matchesGlob(escapedPath, g)) ||
+          (isDir &&
+            compiledGlobs.dir.globs.some(g => matchesGlob(escapedPath, g)))
+        ) {
+          junkPaths.push(path)
+          continue
+        }
+      }
 
-    while (i > 0) {
-      if (seen.has(path.slice(0, i))) break
-      i = path.lastIndexOf('/', i - 1)
+      if (isDir) keptDirPaths.push(path)
+      else keptFiles += 1
     }
 
-    // Skip this path if one of its ancestors has already been kept
-    if (i > 0) continue
+    // Collect removed paths before awaiting (no junk dir recursion = compacting)
+    for (const p of junkPaths) removed.push(p)
+
+    // Size (when tracking), remove junk, and recurse kept subdirs in parallel
+    const [junkSizes, walkResults] = await Promise.all([
+      Promise.all(
+        junkPaths.map(async p => {
+          const size = opts.noSize ? 0 : await treeSize(p)
+          // No rm if --dryRun
+          if (!opts.dryRun) await fs.rm(p, { recursive: true, force: true })
+          return size
+        })
+      ),
+      Promise.all(keptDirPaths.map(walkDir)),
+    ])
+
+    for (const s of junkSizes) removedBlocks += s
+
+    // Subdirs that became empty after pruning their contents
+    const emptyDirs = keptDirPaths.filter((_, i) => !walkResults[i])
+    if (emptyDirs.length > 0) {
+      // No rm if --dryRun
+      if (!opts.dryRun) await Promise.all(emptyDirs.map(d => fs.rmdir(d)))
+    }
 
-    seen.add(path)
-    compact.push(path)
+    return keptFiles + keptDirPaths.length - emptyDirs.length > 0
   }
 
-  return compact
+  await walkDir(opts.path)
+  return { removed, removedBlocks }
 }
 
 /**
- * Checks the rmdir error: ENOTEMPTY means the dir was not empty and the removal
- * failed, which is what we want
- * @param {unknown} err
- * @returns {boolean}
- */
-function hasContent(err) {
-  return (
-    !!err &&
-    typeof err === 'object' &&
-    'code' in err &&
-    (err.code === 'ENOTEMPTY' || err.code === 'ENOENT')
-  )
-}
-
-/**
- * Removes a dir if it's empty
- * @param {string[]} dirs
- * @returns {Promise<void>[]}
- */
-function rmEmptyDir(dirs) {
-  return dirs.map(dir =>
-    fs.rmdir(dir).catch(err => {
-      if (hasContent(err)) return
-      throw err
-    })
-  )
-}
-
-/**
- * Removes a file and collects parent directories for later cleanup
- * @param {string} file - the file to remove
- * @param {Set<string>} visited - tracks directories we've already visited
- * @param {Map<number, Set<string>>} dirDepths - cleanup dirs grouped by depth
- * @param {string} rootDir - stop collecting once we reach this directory
- */
-async function rimraf(
-  file,
-  visited = new Set(),
-  dirDepths = new Map(),
-  rootDir = dirname(file)
-) {
-  // Remove the file/dir recursively
-  await fs.rm(file, { recursive: true, force: true })
-
-  // Walk up the tree collecting all the ancestors, we'll use them later on to
-  // delete directories which are left empty
-  let dir = dirname(file)
-  while (dir !== rootDir) {
-    if (visited.has(dir)) break
-    visited.add(dir)
-
-    const depth = dir.split('/').length
-
-    // Group the dirs by depth
-    const dirs = dirDepths.get(depth)
-    if (dirs) dirs.add(dir)
-    else dirDepths.set(depth, new Set([dir]))
-
-    dir = dirname(dir)
-  }
-}
-
-/**
- * @typedef {Args & { path: string }} ArgsWithRequiredPath
+ * @typedef {Args & { path: string }} ArgsWithPath
  */
 
 /**
  * Removes unneeded files from node_modules
- * @param {ArgsWithRequiredPath} opts
+ * @param {ArgsWithPath} opts
  */
 export async function prune(opts) {
   const startTime = Date.now()
-  log.info('Pruning:', opts.path)
+  const dryRunMsg = opts.dryRun ? ' (--dryRun, nothing deleted)' : ''
+  log.info(`Pruning${dryRunMsg}:`, opts.path)
 
-  // Don't wait
-  const originalSize = getSize(opts.path)
+  // Fire early so du runs concurrently with the walk
+  const sizePromise = opts.noSize ? undefined : getSize(opts.path)
   const excludedGlobs = new Set(opts.exclude)
-  const activeGlobs = [...defaultGlobs, ...opts.include].filter(
-    glob => !excludedGlobs.has(glob)
-  )
+  const activeGlobs = [
+    ...(opts.noGlobs ? [] : defaultGlobs),
+    ...opts.include,
+  ].filter(glob => !excludedGlobs.has(glob))
   const compiledGlobs = compileGlobs(activeGlobs)
 
-  // TODO: this could be slightly faster with an optimized walker
-  const allFiles = await fs.readdir(opts.path, {
-    recursive: true,
-    withFileTypes: true,
-  })
-
-  const junk = compactPaths(findJunkFiles(allFiles, compiledGlobs))
-
+  /** @type {WalkResult} */
+  let result
   try {
-    /** @type {Set<string>} */
-    const visited = new Set()
-    /** @type {Map<number, Set<string>>} */
-    const dirDepths = new Map()
-    // Rm & populate visited & dirDepths so dirs can be removed in parallel
-    await Promise.all(junk.map(x => rimraf(x, visited, dirDepths, opts.path)))
-    const depths = [...dirDepths.keys()].sort((a, b) => b - a)
-
-    /**
-     * Remove one depth level at a time, but parallelize within each level
-     * @param {number} i
-     * @returns {Promise<void>}
-     */
-    async function removeDepth(i) {
-      if (i >= depths.length) return
-      const dirs = dirDepths.get(depths[i] || 0) ?? []
-      await Promise.all(rmEmptyDir([...dirs]))
-      await removeDepth(i + 1)
-    }
-
-    await removeDepth(0)
+    result = await walkAndPrune(compiledGlobs, opts)
   } catch (err) {
     throw bail(undefined, err)
   }
 
-  void printDiff({
-    itemCount: junk.length,
-    prunedSize: opts.noSize ? undefined : getSize(opts.path),
-    originalSize: opts.noSize ? undefined : originalSize,
-    startTime,
-  })
+  if (!opts.dryRun) {
+    printDiff({
+      itemCount: result.removed.length,
+      removedBytes: opts.noSize ? undefined : result.removedBlocks,
+      originalSize: sizePromise ? await sizePromise : undefined,
+      startTime,
+    })
+  }
 
-  return junk
+  return result.removed
 }
 
 const entry = process.argv[1]
@@ -836,21 +862,24 @@ if (runAsScript) {
     process.exit(0)
   }
 
-  if (args.globs) {
+  if (args.showGlobs) {
     log.log(JSON.stringify(defaultGlobs, null, 2))
     process.exit(0)
   }
 
-  // Should have a path by now
+  // From this point forward we should have a path
   if (!args.path) {
-    throw bail(
-      undefined,
-      'Path not defined. Usage: prod-files <path-to-node-modules>'
-    )
+    throw bail(undefined, 'Path not defined. Usage: prod-files <path>')
   }
 
-  const argsWithPath = /** @type {ArgsWithRequiredPath} */ (args)
+  const argsWithPath = /** @type {ArgsWithPath} */ (args)
 
   await validateNodeModulesPath(argsWithPath.path)
-  await prune(argsWithPath)
+  const pruned = await prune(argsWithPath)
+
+  // Print out paths if --dryRun
+  if (args.dryRun) {
+    if (pruned.length === 0) log.log('No results')
+    for (const item of pruned) log.log(item)
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prod-files",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Keep only prod files by pruning non-prod files from node_modules before deploying",
   "keywords": [
     "clean",
@@ -42,6 +42,7 @@
     "test": "node --test",
     "test:e2e": "cd test-project && bash prepare_test.sh && time node ../index.mjs node_modules/.pnpm",
     "test:e2e:nuke": "trash ./test-project/node_modules ./test-project/pnpm-lock.yaml && pnpm store prune",
+    "test:e2e:run": "cd test-project && node ../index.mjs node_modules/.pnpm",
     "test:e2e:weight": "du -sh ./test-project/node_modules/.pnpm | sort -h"
   }
 }