npmdata 0.2.1 → 0.4.0

package/README.md

@@ -1,8 +1,368 @@
-# npmdata — Developer Notes
+# npmdata
 
-This document covers the internal architecture for contributors working on this library.
+Publish folders as npm packages and extract them in any workspace. Use it to distribute shared assets — ML datasets, documentation, ADRs, configuration files — across multiple projects through any npm-compatible registry.
 
-## Module overview
+## How it works
+
+- **Publisher**: a project that has folders to share. Running `init` prepares its `package.json` so those folders are included when the package is published.
+- **Consumer**: any project that installs that package and runs `extract` to download the files locally. A `.publisher` marker file is written alongside the managed files to track ownership and enable safe updates.
+
+## Quick start
+
+### 1. Prepare the publisher package
+
+In the project whose folders you want to share:
+
+```sh
+# share specific folders by glob pattern (required)
+pnpm dlx npmdata init --files "docs/**,data/**,configs/**"
+
+# also bundle an additional package so consumers get data from both sources
+pnpm dlx npmdata init --files "docs/**" --packages shared-configs@^1.0.0
+
+# share multiple additional packages at once
+pnpm dlx npmdata init --files "docs/**" --packages "shared-configs@^1.0.0,base-templates@2.x"
+
+# skip .gitignore entries for managed files (gitignore is enabled by default)
+pnpm dlx npmdata init --files "docs/**,data/**" --no-gitignore
+
+# mark extracted files as unmanaged so consumers can edit them freely;
+# files won't be tracked, made read-only, or added to .gitignore
+pnpm dlx npmdata init --files "templates/**" --unmanaged
+```
+
+`init` updates `package.json` with the right `files`, `bin`, and `dependencies` fields so those folders are included when the package is published, and writes a thin `bin/npmdata.js` entry point. Then publish normally:
+
+```sh
+npm publish
+```
+
+### 2. Extract files in a consumer project
+
+```sh
+# extract all files from the package
+npx npmdata extract --packages my-shared-assets --output ./data
+
+# extract from a specific version
+npx npmdata extract --packages my-shared-assets@^2.0.0 --output ./data
+
+# extract from multiple packages at once
+npx npmdata extract --packages "my-shared-assets@^2.0.0,another-pkg@1.x" --output ./data
+
+# extract only markdown files
+npx npmdata extract --packages my-shared-assets --files "**/*.md" --output ./docs
+
+# extract only files whose content matches a regex
+npx npmdata extract --packages my-shared-assets --content-regex "env: production" --output ./configs
+
+# overwrite files that are unmanaged or owned by a different package;
+# the new package takes ownership in the marker file
+npx npmdata extract --packages my-shared-assets --output ./data --force
+
+# skip .gitignore entries for managed files (gitignore is enabled by default)
+npx npmdata extract --packages my-shared-assets --output ./data --no-gitignore
+
+# write files without a .npmdata marker or .gitignore entry; files won't be read-only
+# and won't be tracked by npmdata; existing files are left unchanged
+npx npmdata extract --packages my-shared-assets --output ./data --unmanaged
+
+# preview what would change without writing any files
+npx npmdata extract --packages my-shared-assets --output ./data --dry-run
+
+# force-reinstall the package even if already installed (e.g. after a floating tag moves)
+npx npmdata extract --packages my-shared-assets@latest --output ./data --upgrade
+```
+
+`extract` logs every file change as it happens:
+
+```
+A	data/users-dataset/user1.json
+M	data/configs/app.config.json
+D	data/old-file.json
+```
+
+If the published package includes its own bin script (normally when it's prepared using "init") you can also call it directly so it extracts data that is inside the package itself:
+
+```sh
+npx my-shared-assets extract --output ./data
+npx my-shared-assets check  --output ./data
+```
+
+When the data package defines multiple `npmdata` entries in its `package.json`, you can limit which entries are processed using the `--tags` option. Only entries whose `tags` list includes at least one of the requested tags will be extracted; entries with no tags are skipped when a tag filter is active.
+
+```sh
+# run only entries tagged with "prod"
+npx my-shared-assets --tags prod
+
+# run entries tagged with either "prod" or "staging"
+npx my-shared-assets --tags prod,staging
+```
+
+To use tags, add a `tags` array to each `npmdata` entry in the data package's `package.json`:
+
+```json
+{
+  "npmdata": [
+    { "package": "my-shared-assets", "outputDir": "./data", "tags": ["prod"] },
+    { "package": "my-dev-assets",    "outputDir": "./dev-data", "tags": ["dev", "staging"] }
+  ]
+}
+```
+
+Check the /examples folder to see this in action
+
+### 3. Check files are in sync
+
+```sh
+npx npmdata check --packages my-shared-assets --output ./data
+# exit 0 = in sync, exit 2 = differences found
+
+# check multiple packages
+npx npmdata check --packages "my-shared-assets,another-pkg" --output ./data
+```
+
+The check command reports differences per package:
+
+```
+my-shared-assets@^2.0.0  FAIL
+  missing:   data/new-file.json
+  modified:  data/configs/app.config.json
+  extra:     data/old-file.json
+```
+
+### 4. List managed files
+
+```sh
+# list all files managed by npmdata in an output directory
+npx npmdata list --output ./data
+```
+
+Output is grouped by package:
+
+```
+my-shared-assets@2.1.0
+  data/users-dataset/user1.json
+  data/configs/app.config.json
+
+another-pkg@1.0.0
+  data/other-file.txt
+```
+
+### 5. Purge managed files
+
+Remove all files previously extracted by one or more packages without touching any other files in the output directory. No network access or package installation is required — only the local `.npmdata` marker state is used.
+
+```sh
+# remove all files managed by a package
+npx npmdata purge --packages my-shared-assets --output ./data
+
+# purge multiple packages at once
+npx npmdata purge --packages "my-shared-assets,another-pkg" --output ./data
+
+# preview what would be deleted without removing anything
+npx npmdata purge --packages my-shared-assets --output ./data --dry-run
+```
+
+After a purge, the corresponding entries are removed from the `.npmdata` marker file and any empty directories are cleaned up. `.gitignore` sections written by `extract` are also removed.
+
+## CLI reference
+
+```
+Usage:
+  npx npmdata [init|extract|check|list|purge] [options]
+
+Commands:
+  init      Set up publishing configuration in a package
+  extract   Extract files from a published package into a local directory
+  check     Verify local files are in sync with the published package
+  list      List all files managed by npmdata in an output directory
+  purge     Remove all managed files previously extracted by given packages
+
+Global options:
+  --help, -h       Show help
+  --version, -v    Show version
+
+Init options:
+  --files <patterns>       Comma-separated glob patterns of files to publish (required)
+                           e.g. "docs/**,data/**,configs/*.json"
+  --packages <specs>       Comma-separated additional package specs to bundle as data sources.
+                           Each spec is "name" or "name@version", e.g.
+                           "shared-configs@^1.0.0,base-templates@2.x".
+                           Listed under `npmdata.additionalPackages` in package.json and
+                           added to `dependencies` so consumers pull data from all of them.
+  --no-gitignore           Skip adding .gitignore entries for managed files
+                           (gitignore is enabled by default)
+  --unmanaged              Mark all generated npmdata entries as unmanaged: extracted files
+                           are written without a .npmdata marker, without updating .gitignore,
+                           and without being made read-only. Existing files are skipped.
+
+Extract options:
+  --packages <specs>       Comma-separated package specs (required).
+                           Each spec is "name" or "name@version", e.g.
+                           "my-pkg@^1.0.0,other-pkg@2.x"
+  --output, -o <dir>       Output directory (default: current directory)
+  --force                  Overwrite existing unmanaged files or files owned by a different package
+  --no-gitignore            Skip creating/updating .gitignore (gitignore is enabled by default)
+  --unmanaged              Write files without a .npmdata marker, .gitignore update, or read-only
+                           flag. Existing files are skipped. Files can be freely edited afterwards
+                           and are not tracked by npmdata.
+  --files <patterns>       Comma-separated glob patterns to filter files
+  --content-regex <regex>  Regex to filter files by content
+  --dry-run                Preview changes without writing any files
+  --upgrade                Reinstall the package even if already present
+
+Check options:
+  --packages <specs>       Same format as extract (required)
+  --output, -o <dir>       Output directory to check (default: current directory)
+
+Purge options:
+  --packages <specs>       Comma-separated package names whose managed files should be removed
+  --output, -o <dir>       Output directory to purge from (default: current directory)
+  --dry-run                Simulate purge without removing any files
+  --silent                 Suppress per-file output
+
+List options:
+  --output, -o <dir>       Output directory to inspect (default: current directory)
+```
+
+## Library usage
+
+`npmdata` also exports a programmatic API:
+
+```typescript
+import { extract, check, list, purge, initPublisher, parsePackageSpec, isBinaryFile } from 'npmdata';
+import type { ConsumerConfig, ConsumerResult, CheckResult, PurgeConfig, ProgressEvent } from 'npmdata';
+
+// extract files from one package
+const result = await extract({
+  packages: ['my-shared-assets@^2.0.0'],
+  outputDir: './data',
+  gitignore: true,
+});
+console.log(result.added, result.modified, result.deleted);
+
+// dry-run: preview changes without writing files
+const preview = await extract({
+  packages: ['my-shared-assets@^2.0.0'],
+  outputDir: './data',
+  dryRun: true,
+});
+console.log('Would add', preview.added, 'files');
+
+// force-reinstall the package even if already present
+await extract({
+  packages: ['my-shared-assets@latest'],
+  outputDir: './data',
+  upgrade: true,
+});
+
+// extract without npmdata tracking: files are writable, no .npmdata marker is written,
+// no .gitignore entry is created. Existing files are left untouched (skipped).
+await extract({
+  packages: ['shared-templates'],
+  outputDir: './templates',
+  unmanaged: true,
+});
+
+// track progress file-by-file
+await extract({
+  packages: ['my-shared-assets@^2.0.0'],
+  outputDir: './data',
+  onProgress: (event: ProgressEvent) => {
+    if (event.type === 'file-added')   console.log('A', event.file);
+    if (event.type === 'file-modified') console.log('M', event.file);
+    if (event.type === 'file-deleted') console.log('D', event.file);
+  },
+});
+
+// extract files from multiple packages into the same output directory
+const multiResult = await extract({
+  packages: ['my-shared-assets@^2.0.0', 'another-pkg@1.x'],
+  outputDir: './data',
+});
+
+// check sync status — per-package breakdown
+const status = await check({
+  packages: ['my-shared-assets'],
+  outputDir: './data',
+});
+if (!status.ok) {
+  console.log('Overall differences:', status.differences);
+  for (const pkg of status.sourcePackages) {
+    if (!pkg.ok) {
+      console.log(pkg.name, 'missing:', pkg.differences.missing);
+      console.log(pkg.name, 'modified:', pkg.differences.modified);
+      console.log(pkg.name, 'extra:', pkg.differences.extra);
+    }
+  }
+}
+
+// remove all files previously extracted by a package (no network required)
+await purge({
+  packages: ['my-shared-assets'],
+  outputDir: './data',
+});
+
+// dry-run: preview what would be deleted without removing anything
+const purgePreview = await purge({
+  packages: ['my-shared-assets'],
+  outputDir: './data',
+  dryRun: true,
+});
+console.log('Would delete', purgePreview.deleted, 'files');
+
+// track progress during purge
+await purge({
+  packages: ['my-shared-assets'],
+  outputDir: './data',
+  onProgress: (event: ProgressEvent) => {
+    if (event.type === 'file-deleted') console.log('D', event.file);
+  },
+});
+
+// list all files managed by npmdata in an output directory
+const managed = await list('./data');
+// managed is Record<string, string[]> keyed by "package@version"
+
+// initialize a publisher package
+await initPublisher(['docs', 'data'], { workingDir: './my-package' });
+
+// utility: parse a package spec string
+const { name, version } = parsePackageSpec('my-pkg@^1.0.0');
+
+// utility: detect whether a file is binary
+const binary = isBinaryFile('/path/to/file.bin');
+```
+
+### `ProgressEvent` type
+
+```typescript
+type ProgressEvent =
+  | { type: 'package-start'; packageName: string; packageVersion: string }
+  | { type: 'package-end';   packageName: string; packageVersion: string }
+  | { type: 'file-added';    packageName: string; file: string }
+  | { type: 'file-modified'; packageName: string; file: string }
+  | { type: 'file-deleted';  packageName: string; file: string }
+  | { type: 'file-skipped';  packageName: string; file: string };
+```
+
+See [lib/README.md](lib/README.md) for the full API reference.
+
+## Managed file tracking
+
+Extracted files are set read-only (`444`) and tracked in a `.publisher` marker file in each output directory. On subsequent extractions:
+
+- Unchanged files are skipped.
+- Updated files are overwritten.
+- Files removed from the package are deleted locally.
+
+The marker file uses a `|`-delimited format; files written by older versions of `npmdata` using the comma-delimited format are read correctly for backward compatibility.
+
+Multiple packages can coexist in the same output directory; each owns its own files.
+
+## Developer Notes
+
+### Module overview
 
 | Module | Purpose |
 |---|---|
@@ -13,11 +373,11 @@ This document covers the internal architecture for contributors working on this
 | `utils.ts` | File I/O helpers: glob matching via `minimatch`, SHA-256 hashing, CSV marker read/write, package manager detection |
 | `types.ts` | Shared TypeScript types and constants (e.g. `DEFAULT_FILENAME_PATTERNS`) |
 
-## Publish side (`publisher.ts`)
+### Publish side (`publisher.ts`)
 
 `initPublisher()` modifies the target `package.json` to include `files`, `bin`, and `dependencies` fields, then writes a thin `bin/npmdata.js` that calls `runner.run(__dirname)`. The generated script is kept minimal on purpose — all logic lives in this library.
 
-## Consumer side (`consumer.ts`)
+### Consumer side (`consumer.ts`)
 
 `extract()` flow:
 1. Detects the package manager (`pnpm` / `yarn` / `npm`) via lock-file presence.
@@ -28,19 +388,18 @@ This document covers the internal architecture for contributors working on this
 
 `check()` performs the same resolution for each package in `config.packages` but compares SHA-256 hashes without writing any files.
 
-## Marker file (`.publisher`)
+### Marker file (`.publisher`)
 
 Each output directory that contains managed files gets a `.publisher` CSV file. Columns: `path`, `packageName`, `packageVersion`, `sha256`. This is the source of truth for drift detection and clean removal.
 
-## Key design decisions
+### Key design decisions
 
 - No runtime dependencies beyond `semver` and `minimatch` to keep the consumer install footprint small.
 - File identity is tracked by path + hash, not by timestamp, to be deterministic across machines.
 - The bin script generated by `initPublisher` contains no logic; all behaviour is versioned inside this library.
 
-## Dev workflow
+### Dev workflow
 
 ```
 make build lint-fix test
 ```
-

package/bin/npmdata.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// DON'T EDIT THIS FILE MANUALLY - this script is generated by "npmdata init" command
+require('npmdata/dist/runner.js').run(__dirname);

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAaA;;GAEG;AAEH,wBAAsB,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAwPhE"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAaA;;GAEG;AAEH,wBAAsB,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAgVhE"}

package/dist/cli.js

@@ -37,39 +37,53 @@ async function cli(processArgs) {
     // Handle init command
     if (command === 'init') {
         // eslint-disable-next-line functional/no-let
-        let sourceFoldersFlag;
+        let sourceFilesFlag;
         // eslint-disable-next-line functional/no-let
         let additionalPackagesFlag;
-        // Parse args for --folders and --packages flags
+        // eslint-disable-next-line functional/no-let
+        let initGitignore = true;
+        // eslint-disable-next-line functional/no-let
+        let initUnmanaged = false;
+        // Parse args for --files and --packages flags
         // eslint-disable-next-line functional/no-let
         for (let i = 1; i < args.length; i += 1) {
-            if (args[i] === '--folders') {
+            if (args[i] === '--files') {
                 // eslint-disable-next-line no-plusplus
-                sourceFoldersFlag = args[++i];
+                sourceFilesFlag = args[++i];
             }
             else if (args[i] === '--packages') {
                 // eslint-disable-next-line no-plusplus
                 additionalPackagesFlag = args[++i];
             }
+            else if (args[i] === '--no-gitignore') {
+                initGitignore = false;
+            }
+            else if (args[i] === '--unmanaged') {
+                initUnmanaged = true;
+            }
         }
-        // --folders is required
-        if (!sourceFoldersFlag) {
-            console.error('Error: --folders option is required for init command');
+        // --files is required
+        if (!sourceFilesFlag) {
+            console.error('Error: --files option is required for init command');
             printUsage();
             return 1;
         }
-        const folders = sourceFoldersFlag.split(',').map((f) => f.trim());
+        const fileGlobs = sourceFilesFlag.split(',').map((f) => f.trim());
         const additionalPackages = additionalPackagesFlag
             ? additionalPackagesFlag.split(',').map((p) => p.trim())
             : [];
-        const result = await (0, publisher_1.initPublisher)(folders, { additionalPackages });
+        const result = await (0, publisher_1.initPublisher)(fileGlobs, {
+            additionalPackages,
+            gitignore: initGitignore,
+            ...(initUnmanaged ? { unmanaged: true } : {}),
+        });
         if (!result.success) {
             console.error(`\nError: ${result.message}`);
             return 1;
         }
         console.log(`\n${result.message}`);
-        if (result.publishedFolders) {
-            console.log(`\nThe following folders will be published: ${result.publishedFolders.join(', ')}`);
+        if (result.publishedFiles) {
+            console.log(`\nThe following file patterns will be published: ${result.publishedFiles.join(', ')}`);
         }
         if (result.additionalPackages && result.additionalPackages.length > 0) {
             console.log(`\nAdditional data source packages: ${result.additionalPackages.join(', ')}`);
@@ -106,19 +120,85 @@ async function cli(processArgs) {
         }
         return 0;
     }
+    // Handle purge command
+    if (command === 'purge') {
+        let purgePackageSpecs;
+        let purgeOutDir = process.cwd();
+        let purgeOutputFlagProvided = false;
+        let purgeDryRun = false;
+        let purgeSilent = false;
+        for (let i = 1; i < args.length; i++) {
+            if (args[i] === '--packages') {
+                purgePackageSpecs = args[++i];
+            }
+            else if (args[i] === '--output' || args[i] === '-o') {
+                purgeOutDir = args[++i];
+                purgeOutputFlagProvided = true;
+            }
+            else if (args[i] === '--dry-run') {
+                purgeDryRun = true;
+            }
+            else if (args[i] === '--silent') {
+                purgeSilent = true;
+            }
+            else if (!args[i].startsWith('-')) {
+                purgeOutDir = args[i];
+                purgeOutputFlagProvided = true;
+            }
+        }
+        if (!purgePackageSpecs) {
+            console.error(`Error: --packages option is required for 'purge' command`);
+            printUsage();
+            return 1;
+        }
+        if (!purgeOutputFlagProvided && !purgeSilent) {
+            console.info(`No --output specified. Using current directory: ${purgeOutDir}`);
+        }
+        const purgePackages = purgePackageSpecs.split(',').map((s) => s.trim());
+        const purgeOnProgress = purgeSilent
+            ? // eslint-disable-next-line no-undefined
+                undefined
+            : (event) => {
+                switch (event.type) {
+                    case 'package-start':
+                        console.log(`\n>> Package ${event.packageName}`);
+                        break;
+                    case 'file-deleted':
+                        console.log(`D\t${event.file}`);
+                        break;
+                    default:
+                        break;
+                }
+            };
+        if (!purgeSilent) {
+            if (purgeDryRun)
+                console.info('Dry run: simulating purge (no files will be removed)...');
+            else
+                console.info('Purging managed files...');
+        }
+        const purgeResult = await (0, consumer_1.purge)({
+            packages: purgePackages,
+            outputDir: node_path_1.default.resolve(purgeOutDir),
+            dryRun: purgeDryRun,
+            onProgress: purgeOnProgress,
+        });
+        console.log(`\nPurge complete: ${purgeResult.deleted.length} deleted${purgeDryRun ? ' (dry run)' : ''}`);
+        return 0;
+    }
     // Consumer commands (extract, check)
     if (!['extract', 'check'].includes(command)) {
-        console.error(`Error: unknown command '${command}'. Use 'init', 'extract', 'check', or 'list'`);
+        console.error(`Error: unknown command '${command}'. Use 'init', 'extract', 'check', 'purge', or 'list'`);
         printUsage();
         return 1;
     }
     // Parse options common to extract and check
     let packageSpecs;
     let force = false;
-    let gitignore = false;
+    let gitignore = true;
     let dryRun = false;
     let upgrade = false;
     let silent = false;
+    let unmanaged = false;
     let filenamePatterns;
     let contentRegexes;
     let outDir = process.cwd();
@@ -133,8 +213,8 @@ async function cli(processArgs) {
         else if (args[i] === '--silent') {
             silent = true;
         }
-        else if (args[i] === '--gitignore') {
-            gitignore = true;
+        else if (args[i] === '--no-gitignore') {
+            gitignore = false;
         }
         else if (args[i] === '--dry-run') {
             dryRun = true;
@@ -142,6 +222,9 @@ async function cli(processArgs) {
         else if (args[i] === '--upgrade') {
             upgrade = true;
         }
+        else if (args[i] === '--unmanaged') {
+            unmanaged = true;
+        }
         else if (args[i] === '--files') {
             filenamePatterns = args[++i];
         }
@@ -195,6 +278,7 @@ async function cli(processArgs) {
         gitignore,
         dryRun,
         upgrade,
+        unmanaged,
         onProgress,
         filenamePatterns: filenamePatterns
             ? filenamePatterns.split(',')
@@ -250,12 +334,13 @@ function printUsage() {
 npmdata
 
 Usage:
-  npx npmdata [init|extract|check|list] [options]
+  npx npmdata [init|extract|check|purge|list] [options]
 
 Commands:
   init                         Initialize publishing configuration
   extract                      Extract files from one or more published packages
   check                        Verify if local files are in sync with packages
+  purge                        Remove all managed files written by given packages
   list                         List all managed files in the output directory
 
 Global Options:
@@ -263,10 +348,12 @@ Global Options:
   --version, -v                Show version
 
 Init Options:
-  --folders <folders>          Comma-separated list of source folders to publish (required)
+  --files <patterns>           Comma-separated glob patterns of files to publish (required)
+                               e.g. "docs/**,data/**,configs/*.json"
   --packages <specs>           Comma-separated additional package specs to use as data sources.
                                Each spec is "name" or "name@version"
                                e.g. "shared-data@^1.0.0,other-pkg@2.x"
+  --unmanaged                  Mark all npmdata entries as unmanaged (see Extract options)
 
 Extract / Check Options:
   --packages <specs>           Comma-separated package specs to extract from (required).
@@ -274,18 +361,27 @@ Extract / Check Options:
                                e.g. "my-pkg@^1.2.3,other-pkg@2.x"
   --output, -o <dir>           Output directory (default: current directory, with a warning)
   --force                      Allow overwriting existing unmanaged files
-  --gitignore                  Create/update .gitignore to ignore managed files and .publisher
+  --no-gitignore               Skip creating/updating .gitignore (gitignore is enabled by default)
+  --unmanaged                  Write files without a .npmdata marker, .gitignore update, or
+                               read-only flag. Existing files are skipped. Files can be freely
+                               edited afterwards and are not tracked by npmdata.
   --dry-run                    Simulate extraction without writing any files
   --upgrade                    Re-install packages even when a satisfying version is installed
   --silent                     Print only the final result line, suppressing package and file listing
   --files <pattern>            Comma-separated shell glob patterns to filter files
   --content-regex <regex>      Regex pattern to match file contents
 
+Purge Options:
+  --packages <specs>           Comma-separated package names whose managed files should be removed
+  --output, -o <dir>           Output directory to purge from (default: current directory)
+  --dry-run                    Simulate purge without removing any files
+  --silent                     Suppress per-file output
+
 List Options:
   --output, -o <dir>           Directory to inspect (default: current directory)
 
 Examples:
-  npx npmdata init --folders "data,docs,config"
+  npx npmdata init --files "data/**,docs/**,configs/*.json"
   npx npmdata extract --packages mydataset --output ./data
   npx npmdata extract --packages mydataset@^2.0.0 --output ./data
   npx npmdata extract --packages "mydataset@^2.0.0,otherpkg@1.x" --output ./data
@@ -296,6 +392,8 @@ Examples:
   npx npmdata check --packages mydataset --output ./data
   npx npmdata check --packages "mydataset,otherpkg" --output ./data
   npx npmdata list --output ./data
+  npx npmdata purge --packages mydataset --output ./data
+  npx npmdata purge --packages "mydataset,otherpkg" --output ./data
 `);
 }
 //# sourceMappingURL=cli.js.map