dotenv-diff 1.6.4 → 1.6.5

package/README.md

@@ -43,6 +43,15 @@ When using the `--check-values` option, the tool will also compare the actual va
 
 `dotenv-diff` warns when a `.env*` file contains the same key multiple times. The last occurrence wins. Suppress these warnings with `--allow-duplicates`.
 
+## Only show specific categories
+
+Use the `--only` flag to restrict the comparison to specific categories. For example:
+
+```bash
+dotenv-diff --only missing,extra
+```
+This will only show missing and extra keys, ignoring empty, mismatched, duplicate keys and so on.
+
 ## Ignore specific keys
 
 Exclude certain keys from the comparison using `--ignore` for exact names or `--ignore-regex` for patterns:

package/dist/src/cli/program.js

@@ -11,5 +11,6 @@ export function createProgram() {
         .option('--allow-duplicates', 'Do not warn about duplicate keys in .env* files')
         .option('--ignore <keys>', 'Comma-separated list of keys to ignore')
         .option('--ignore-regex <pattern>', 'Regex pattern to ignore matching keys')
-        .option('--json', 'Output results in JSON format');
+        .option('--json', 'Output results in JSON format')
+        .option('--only <list>', 'Comma-separated categories to only run (missing,extra,empty,mismatch,duplicate,gitignore)');
 }

package/dist/src/cli/run.js

@@ -37,6 +37,7 @@ export async function run(program) {
             json: opts.json,
             ignore: opts.ignore,
             ignoreRegex: opts.ignoreRegex,
+            only: opts.only,
             collect: (e) => report.push(e),
         });
         if (opts.json) {
@@ -75,6 +76,7 @@ export async function run(program) {
         json: opts.json,
         ignore: opts.ignore,
         ignoreRegex: opts.ignoreRegex,
+        only: opts.only,
         collect: (e) => report.push(e),
     });
     if (opts.json) {

package/dist/src/commands/compare.d.ts

@@ -1,29 +1,4 @@
-export type CompareJsonEntry = {
-    env: string;
-    example: string;
-    skipped?: {
-        reason: string;
-    };
-    duplicates?: {
-        env?: Array<{
-            key: string;
-            count: number;
-        }>;
-        example?: Array<{
-            key: string;
-            count: number;
-        }>;
-    };
-    missing?: string[];
-    extra?: string[];
-    empty?: string[];
-    valueMismatches?: Array<{
-        key: string;
-        expected: string;
-        actual: string;
-    }>;
-    ok?: boolean;
-};
+import type { Category, CompareJsonEntry } from '../config/types.js';
 export declare function compareMany(pairs: Array<{
     envName: string;
     envPath: string;
@@ -36,6 +11,7 @@ export declare function compareMany(pairs: Array<{
     ignore: string[];
     ignoreRegex: RegExp[];
     collect?: (entry: CompareJsonEntry) => void;
+    only?: Category[];
 }): Promise<{
     exitWithError: boolean;
 }>;

package/dist/src/commands/compare.js

@@ -8,6 +8,18 @@ import { findDuplicateKeys } from '../services/duplicates.js';
 import { filterIgnoredKeys } from '../core/filterIgnoredKeys.js';
 export async function compareMany(pairs, opts) {
     let exitWithError = false;
+    const onlySet = opts.only?.length
+        ? new Set(opts.only)
+        : undefined;
+    const run = (cat) => !onlySet || onlySet.has(cat);
+    const totals = {
+        missing: 0,
+        extra: 0,
+        empty: 0,
+        mismatch: 0,
+        duplicate: 0,
+        gitignore: 0,
+    };
     for (const { envName, envPath, examplePath } of pairs) {
         const exampleName = path.basename(examplePath);
         const entry = { env: envName, example: exampleName };
@@ -25,19 +37,28 @@ export async function compareMany(pairs, opts) {
             console.log(chalk.bold(`🔍 Comparing ${envName} ↔ ${exampleName}...`));
         }
         // Git ignore hint (only when not JSON)
-        warnIfEnvNotIgnored({
-            cwd: opts.cwd,
-            envFile: envName,
-            log: (msg) => {
-                if (!opts.json)
-                    console.log(msg.replace(/^/gm, '  '));
-            },
-        });
-        // Duplicate detection
-        if (!opts.allowDuplicates) {
-            const dupsEnv = findDuplicateKeys(envPath).filter(({ key }) => !opts.ignore.includes(key) &&
+        let gitignoreUnsafe = false;
+        if (run('gitignore')) {
+            warnIfEnvNotIgnored({
+                cwd: opts.cwd,
+                envFile: envName,
+                log: (msg) => {
+                    gitignoreUnsafe = true;
+                    if (!opts.json)
+                        console.log(msg.replace(/^/gm, '  '));
+                },
+            });
+        }
+        else {
+            // still call to keep previous hints? No—masked by --only.
+        }
+        // Duplicate detection (skip entirely if --only excludes it)
+        let dupsEnv = [];
+        let dupsEx = [];
+        if (!opts.allowDuplicates && run('duplicate')) {
+            dupsEnv = findDuplicateKeys(envPath).filter(({ key }) => !opts.ignore.includes(key) &&
                 !opts.ignoreRegex.some((rx) => rx.test(key)));
-            const dupsEx = findDuplicateKeys(examplePath).filter(({ key }) => !opts.ignore.includes(key) &&
+            dupsEx = findDuplicateKeys(examplePath).filter(({ key }) => !opts.ignore.includes(key) &&
                 !opts.ignoreRegex.some((rx) => rx.test(key)));
             if (dupsEnv.length || dupsEx.length) {
                 entry.duplicates = {};
@@ -68,10 +89,19 @@ export async function compareMany(pairs, opts) {
         const emptyKeys = Object.entries(current)
             .filter(([, v]) => (v ?? '').trim() === '')
             .map(([k]) => k);
-        const allOk = diff.missing.length === 0 &&
-            diff.extra.length === 0 &&
-            emptyKeys.length === 0 &&
-            diff.valueMismatches.length === 0;
+        const filtered = {
+            missing: run('missing') ? diff.missing : [],
+            extra: run('extra') ? diff.extra : [],
+            empty: run('empty') ? emptyKeys : [],
+            mismatches: run('mismatch') && opts.checkValues ? diff.valueMismatches : [],
+            duplicatesEnv: run('duplicate') ? dupsEnv : [],
+            duplicatesEx: run('duplicate') ? dupsEx : [],
+            gitignoreUnsafe: run('gitignore') ? gitignoreUnsafe : false,
+        };
+        const allOk = filtered.missing.length === 0 &&
+            filtered.extra.length === 0 &&
+            filtered.empty.length === 0 &&
+            filtered.mismatches.length === 0;
         if (allOk) {
             entry.ok = true;
             if (!opts.json) {
@@ -81,33 +111,51 @@ export async function compareMany(pairs, opts) {
             opts.collect?.(entry);
             continue;
         }
-        if (diff.missing.length) {
-            entry.missing = diff.missing;
+        if (filtered.missing.length) {
+            entry.missing = filtered.missing;
+            exitWithError = true;
+            totals.missing += filtered.missing.length;
+        }
+        if (filtered.extra.length) {
+            entry.extra = filtered.extra;
+            exitWithError = true;
+            totals.extra += filtered.extra.length;
+        }
+        if (filtered.empty.length) {
+            entry.empty = filtered.empty;
             exitWithError = true;
+            totals.empty += filtered.empty.length;
         }
-        if (diff.extra.length)
-            entry.extra = diff.extra;
-        if (emptyKeys.length)
-            entry.empty = emptyKeys;
-        if (opts.checkValues && diff.valueMismatches.length) {
-            entry.valueMismatches = diff.valueMismatches;
+        if (filtered.mismatches.length) {
+            entry.valueMismatches = filtered.mismatches;
+            totals.mismatch += filtered.mismatches.length;
+            exitWithError = true;
+        }
+        if (filtered.duplicatesEnv.length || filtered.duplicatesEx.length) {
+            totals.duplicate +=
+                filtered.duplicatesEnv.length + filtered.duplicatesEx.length;
+            exitWithError = true;
+        }
+        if (filtered.gitignoreUnsafe) {
+            totals.gitignore += 1;
+            exitWithError = true;
         }
         if (!opts.json) {
-            if (diff.missing.length) {
+            if (filtered.missing.length) {
                 console.log(chalk.red('  ❌ Missing keys:'));
-                diff.missing.forEach((key) => console.log(chalk.red(`      - ${key}`)));
+                filtered.missing.forEach((key) => console.log(chalk.red(`      - ${key}`)));
             }
-            if (diff.extra.length) {
+            if (filtered.extra.length) {
                 console.log(chalk.yellow('  ⚠️  Extra keys (not in example):'));
-                diff.extra.forEach((key) => console.log(chalk.yellow(`      - ${key}`)));
+                filtered.extra.forEach((key) => console.log(chalk.yellow(`      - ${key}`)));
             }
-            if (emptyKeys.length) {
+            if (filtered.empty.length) {
                 console.log(chalk.yellow('  ⚠️  Empty values:'));
-                emptyKeys.forEach((key) => console.log(chalk.yellow(`      - ${key}`)));
+                filtered.empty.forEach((key) => console.log(chalk.yellow(`      - ${key}`)));
             }
-            if (opts.checkValues && diff.valueMismatches.length) {
+            if (filtered.mismatches.length) {
                 console.log(chalk.yellow('  ⚠️  Value mismatches:'));
-                diff.valueMismatches.forEach(({ key, expected, actual }) => console.log(chalk.yellow(`      - ${key}: expected '${expected}', but got '${actual}'`)));
+                filtered.mismatches.forEach(({ key, expected, actual }) => console.log(chalk.yellow(`      - ${key}: expected '${expected}', but got '${actual}'`)));
             }
             console.log();
         }

package/dist/src/config/options.d.ts

@@ -1,25 +1,2 @@
-export type Options = {
-    checkValues: boolean;
-    isCiMode: boolean;
-    isYesMode: boolean;
-    allowDuplicates: boolean;
-    json: boolean;
-    envFlag: string | null;
-    exampleFlag: string | null;
-    ignore: string[];
-    ignoreRegex: RegExp[];
-    cwd: string;
-};
-type RawOptions = {
-    checkValues?: boolean;
-    ci?: boolean;
-    yes?: boolean;
-    allowDuplicates?: boolean;
-    json?: boolean;
-    env?: string;
-    example?: string;
-    ignore?: string | string[];
-    ignoreRegex?: string | string[];
-};
+import { Options, RawOptions } from './types.js';
 export declare function normalizeOptions(raw: RawOptions): Options;
-export {};

package/dist/src/config/options.js

@@ -1,18 +1,30 @@
 import chalk from 'chalk';
 import path from 'path';
+import { ALLOWED_CATEGORIES } from './types.js';
+function parseList(val) {
+    const arr = Array.isArray(val) ? val : val ? [val] : [];
+    return arr
+        .flatMap((s) => String(s).split(','))
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function parseCategories(val, flagName = '') {
+    const raw = parseList(val);
+    const bad = raw.filter((c) => !ALLOWED_CATEGORIES.includes(c));
+    if (bad.length) {
+        console.error(chalk.red(`❌ Error: invalid ${flagName} value(s): ${bad.join(', ')}. Allowed: ${ALLOWED_CATEGORIES.join(', ')}`));
+        process.exit(1);
+    }
+    return raw;
+}
 export function normalizeOptions(raw) {
     const checkValues = raw.checkValues ?? false;
     const isCiMode = Boolean(raw.ci);
     const isYesMode = Boolean(raw.yes);
     const allowDuplicates = Boolean(raw.allowDuplicates);
     const json = Boolean(raw.json);
-    const parseList = (val) => {
-        const arr = Array.isArray(val) ? val : val ? [val] : [];
-        return arr
-            .flatMap((s) => s.split(','))
-            .map((s) => s.trim())
-            .filter(Boolean);
-    };
+    const onlyParsed = parseCategories(raw.only, '--only');
+    const only = onlyParsed.length ? onlyParsed : undefined;
     const ignore = parseList(raw.ignore);
     const ignoreRegex = [];
     for (const pattern of parseList(raw.ignoreRegex)) {
@@ -41,5 +53,6 @@ export function normalizeOptions(raw) {
         ignore,
         ignoreRegex,
         cwd,
+        only,
     };
 }

package/dist/src/config/types.d.ts

@@ -0,0 +1,53 @@
+export declare const ALLOWED_CATEGORIES: readonly ["missing", "extra", "empty", "mismatch", "duplicate", "gitignore"];
+export type Category = (typeof ALLOWED_CATEGORIES)[number];
+export type Options = {
+    checkValues: boolean;
+    isCiMode: boolean;
+    isYesMode: boolean;
+    allowDuplicates: boolean;
+    json: boolean;
+    envFlag: string | null;
+    exampleFlag: string | null;
+    ignore: string[];
+    ignoreRegex: RegExp[];
+    cwd: string;
+    only?: Category[];
+};
+export type RawOptions = {
+    checkValues?: boolean;
+    ci?: boolean;
+    yes?: boolean;
+    allowDuplicates?: boolean;
+    json?: boolean;
+    env?: string;
+    example?: string;
+    ignore?: string | string[];
+    ignoreRegex?: string | string[];
+    only?: string | string[];
+};
+export type CompareJsonEntry = {
+    env: string;
+    example: string;
+    skipped?: {
+        reason: string;
+    };
+    duplicates?: {
+        env?: Array<{
+            key: string;
+            count: number;
+        }>;
+        example?: Array<{
+            key: string;
+            count: number;
+        }>;
+    };
+    missing?: string[];
+    extra?: string[];
+    empty?: string[];
+    valueMismatches?: Array<{
+        key: string;
+        expected: string;
+        actual: string;
+    }>;
+    ok?: boolean;
+};

package/dist/src/config/types.js

@@ -0,0 +1,8 @@
+export const ALLOWED_CATEGORIES = [
+    'missing',
+    'extra',
+    'empty',
+    'mismatch',
+    'duplicate',
+    'gitignore',
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotenv-diff",
-  "version": "1.6.4",
+  "version": "1.6.5",
   "type": "module",
   "description": "A CLI tool to find differences between .env and .env.example / .env.* files.",
   "bin": {