Add warning log for supersedes

Author: roryabraham

scripts/utils/CLI.ts

@@ -218,25 +218,30 @@ class CLI<TConfig extends CLIConfig> {
                 if (providedNamedArgs.has(name) && spec.supersedes) {
                     for (const supersededArg of spec.supersedes) {
                         supersededArgs.add(supersededArg);
+                        if (providedNamedArgs.has(supersededArg)) {
+                            console.warn(`⚠️  Warning: --${supersededArg} is superseded by --${name} and will be ignored.`);
+                        }
                     }
                 }
             }
 
             // Validate that all required args are present, assign defaults where values are not parsed
             for (const [name, spec] of Object.entries(config.namedArgs ?? {})) {
-                if (!(name in parsedNamedArgs)) {
+                if (name in parsedNamedArgs) {
                     if (supersededArgs.has(name)) {
-                        // This arg was superseded, so don't require it and don't assign a default
-                        continue;
-                    } else if (spec.default !== undefined) {
-                        parsedNamedArgs[name as keyof typeof parsedNamedArgs] = spec.default as ValueOf<typeof parsedNamedArgs>;
-                    } else if (spec.required === false) {
-                        // Explicitly marked as optional, leave undefined
-                        continue;
-                    } else {
-                        // Arguments without defaults are required by default (unless explicitly marked as optional)
-                        throw new Error(`Missing required named argument --${name}`);
+                        parsedNamedArgs[name as keyof typeof parsedNamedArgs] = undefined as ValueOf<typeof parsedNamedArgs>;
                     }
+                } else if (supersededArgs.has(name)) {
+                    // This arg was superseded, so don't require it and don't assign a default
+                    continue;
+                } else if (spec.default !== undefined) {
+                    parsedNamedArgs[name as keyof typeof parsedNamedArgs] = spec.default as ValueOf<typeof parsedNamedArgs>;
+                } else if (spec.required === false) {
+                    // Explicitly marked as optional, leave undefined
+                    continue;
+                } else {
+                    // Arguments without defaults are required by default (unless explicitly marked as optional)
+                    throw new Error(`Missing required named argument --${name}`);
                 }
             }
 

tests/unit/CLITests.ts

@@ -9,6 +9,7 @@ describe('CLI', () => {
     let mockExit: jest.SpyInstance;
     let mockLog: jest.SpyInstance;
     let mockError: jest.SpyInstance;
+    let mockWarn: jest.SpyInstance;
 
     beforeEach(() => {
         process.argv = ['ts-node', 'script.ts'];
@@ -17,6 +18,7 @@ describe('CLI', () => {
         });
         mockLog = jest.spyOn(console, 'log').mockImplementation(() => {});
         mockError = jest.spyOn(console, 'error').mockImplementation(() => {});
+        mockWarn = jest.spyOn(console, 'warn').mockImplementation(() => {});
     });
 
     afterEach(() => {
@@ -322,4 +324,81 @@ describe('CLI', () => {
         ).toThrow();
         expect(mockError).toHaveBeenCalledWith('Missing required named argument --compareRef');
     });
+
+    it('warns when superseded arg is provided alongside superseding arg', () => {
+        process.argv.push('--paths', 'common.save', '--compare-ref', 'main');
+        /* eslint-disable @typescript-eslint/naming-convention */
+        const cli = new CLI({
+            namedArgs: {
+                'compare-ref': {
+                    description: 'Compare reference',
+                    default: 'main',
+                },
+                paths: {
+                    description: 'Specific paths to process',
+                    parse: (val) => val.split(','),
+                    supersedes: ['compare-ref'],
+                    required: false,
+                },
+            },
+        });
+        /* eslint-enable @typescript-eslint/naming-convention */
+
+        expect(mockWarn).toHaveBeenCalledWith('⚠️  Warning: --compare-ref is superseded by --paths and will be ignored.');
+        expect(cli.namedArgs.paths).toEqual(['common.save']);
+        expect(cli.namedArgs['compare-ref']).toBeUndefined();
+    });
+
+    it('warns for multiple superseded args when provided', () => {
+        process.argv.push('--priority', 'high', '--low-priority', 'disabled', '--medium-priority', 'enabled');
+        /* eslint-disable @typescript-eslint/naming-convention */
+        const cli = new CLI({
+            namedArgs: {
+                'low-priority': {
+                    description: 'Low priority mode',
+                    default: 'enabled',
+                },
+                'medium-priority': {
+                    description: 'Medium priority mode',
+                    default: 'enabled',
+                },
+                priority: {
+                    description: 'Priority level',
+                    supersedes: ['low-priority', 'medium-priority'],
+                    required: false,
+                },
+            },
+        });
+        /* eslint-enable @typescript-eslint/naming-convention */
+
+        expect(mockWarn).toHaveBeenCalledWith('⚠️  Warning: --low-priority is superseded by --priority and will be ignored.');
+        expect(mockWarn).toHaveBeenCalledWith('⚠️  Warning: --medium-priority is superseded by --priority and will be ignored.');
+        expect(cli.namedArgs.priority).toBe('high');
+        expect(cli.namedArgs['low-priority']).toBeUndefined();
+        expect(cli.namedArgs['medium-priority']).toBeUndefined();
+    });
+
+    it('does not warn when only superseding arg is provided', () => {
+        process.argv.push('--paths', 'common.save');
+        /* eslint-disable @typescript-eslint/naming-convention */
+        const cli = new CLI({
+            namedArgs: {
+                'compare-ref': {
+                    description: 'Compare reference',
+                    default: 'main',
+                },
+                paths: {
+                    description: 'Specific paths to process',
+                    parse: (val) => val.split(','),
+                    supersedes: ['compare-ref'],
+                    required: false,
+                },
+            },
+        });
+        /* eslint-enable @typescript-eslint/naming-convention */
+
+        expect(mockWarn).not.toHaveBeenCalled();
+        expect(cli.namedArgs.paths).toEqual(['common.save']);
+        expect(cli.namedArgs['compare-ref']).toBeUndefined();
+    });
 });