From 5cf501a5e491a32e8c946c78d746a2b19b3714f5 Mon Sep 17 00:00:00 2001
From: Luka Leer <luka.leer@gmail.com>
Date: Fri, 11 Oct 2024 14:59:42 +0200
Subject: [PATCH 1/3] =?UTF-8?q?=E2=9C=A8=20Add=20support=20for=20Deno=20sh?=
 =?UTF-8?q?ortcuts=20and=20wildcards?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Luka Leer <luka.leer@gmail.com>
---
 docs/cli/shortcuts.md                         |   3 +-
 .../expand-npm-shortcut.spec.ts               |  25 +-
 src/command-parser/expand-npm-shortcut.ts     |  31 ++-
 .../expand-npm-wildcard.spec.ts               | 227 +++++++++++++++---
 src/command-parser/expand-npm-wildcard.ts     |  94 +++++---
 5 files changed, 295 insertions(+), 85 deletions(-)

diff --git a/docs/cli/shortcuts.md b/docs/cli/shortcuts.md
index 36bbf19a..d0a79d8a 100644
--- a/docs/cli/shortcuts.md
+++ b/docs/cli/shortcuts.md
@@ -1,6 +1,6 @@
 # Command Shortcuts
 
-Package managers that execute scripts from a `package.json` file can be shortened when in concurrently.<br/>
+Package managers that execute scripts from a `package.json` or `deno.json` file can be shortened when in concurrently.<br/>
 The following are supported:
 
 | Syntax          | Expands to            |
@@ -10,6 +10,7 @@ The following are supported:
 | `yarn:<script>` | `yarn run <script>`   |
 | `bun:<script>`  | `bun run <script>`    |
 | `node:<script>` | `node --run <script>` |
+| `deno:<script>` | `deno task <script>`  |
 
 > [!NOTE]
 >
diff --git a/src/command-parser/expand-npm-shortcut.spec.ts b/src/command-parser/expand-npm-shortcut.spec.ts
index eb6ac202..c43b984d 100644
--- a/src/command-parser/expand-npm-shortcut.spec.ts
+++ b/src/command-parser/expand-npm-shortcut.spec.ts
@@ -8,33 +8,34 @@ const createCommandInfo = (command: string, name = ''): CommandInfo => ({
     command,
 });
 
-it('returns same command if no npm: prefix is present', () => {
+it('returns same command if no prefix is present', () => {
     const commandInfo = createCommandInfo('echo foo');
     expect(parser.parse(commandInfo)).toBe(commandInfo);
 });
 
 describe.each([
-    ['npm', 'run'],
-    ['yarn', 'run'],
-    ['pnpm', 'run'],
-    ['bun', 'run'],
-    ['node', '--run'],
-])(`with %s: prefix`, (npmCmd, runCmd) => {
-    it(`expands to "${npmCmd} ${runCmd} <script> <args>"`, () => {
-        const commandInfo = createCommandInfo(`${npmCmd}:foo -- bar`, 'echo');
+    ['npm', 'npm run'],
+    ['yarn', 'yarn run'],
+    ['pnpm', 'pnpm run'],
+    ['bun', 'bun run'],
+    ['node', 'node --run'],
+    ['deno', 'deno task'],
+])(`with '%s:' prefix`, (prefix, command) => {
+    it(`expands to "${command} <script> <args>"`, () => {
+        const commandInfo = createCommandInfo(`${prefix}:foo -- bar`, 'echo');
         expect(parser.parse(commandInfo)).toEqual({
             ...commandInfo,
             name: 'echo',
-            command: `${npmCmd} ${runCmd} foo -- bar`,
+            command: `${command} foo -- bar`,
         });
     });
 
     it('sets name to script name if none', () => {
-        const commandInfo = createCommandInfo(`${npmCmd}:foo -- bar`);
+        const commandInfo = createCommandInfo(`${prefix}:foo -- bar`);
         expect(parser.parse(commandInfo)).toEqual({
             ...commandInfo,
             name: 'foo',
-            command: `${npmCmd} ${runCmd} foo -- bar`,
+            command: `${command} foo -- bar`,
         });
     });
 });
diff --git a/src/command-parser/expand-npm-shortcut.ts b/src/command-parser/expand-npm-shortcut.ts
index bc681582..7395c8c8 100644
--- a/src/command-parser/expand-npm-shortcut.ts
+++ b/src/command-parser/expand-npm-shortcut.ts
@@ -2,21 +2,38 @@ import { CommandInfo } from '../command';
 import { CommandParser } from './command-parser';
 
 /**
- * Expands commands prefixed with `node:`, `npm:`, `yarn:`, `pnpm:`, or `bun:` into the full version `npm run <command>` and so on.
+ * Expands shortcuts according to the following table:
+ *
+ * | Syntax          | Expands to            |
+ * | --------------- | --------------------- |
+ * | `npm:<script>`  | `npm run <script>`    |
+ * | `pnpm:<script>` | `pnpm run <script>`   |
+ * | `yarn:<script>` | `yarn run <script>`   |
+ * | `bun:<script>`  | `bun run <script>`    |
+ * | `node:<script>` | `node --run <script>` |
+ * | `deno:<script>` | `deno task <script>`  |
  */
 export class ExpandNpmShortcut implements CommandParser {
     parse(commandInfo: CommandInfo) {
-        const [, npmCmd, cmdName, args] =
-            commandInfo.command.match(/^(node|npm|yarn|pnpm|bun):(\S+)(.*)/) || [];
-        if (!cmdName) {
+        const [, prefix, script, args] =
+            /^(npm|yarn|pnpm|bun|node|deno):(\S+)(.*)/.exec(commandInfo.command) || [];
+        if (!script) {
             return commandInfo;
         }
 
-        const runCmd = npmCmd === 'node' ? '--run' : 'run';
+        let command: string;
+        if (prefix === 'node') {
+            command = 'node --run';
+        } else if (prefix === 'deno') {
+            command = 'deno task';
+        } else {
+            command = `${prefix} run`;
+        }
+
         return {
             ...commandInfo,
-            name: commandInfo.name || cmdName,
-            command: `${npmCmd} ${runCmd} ${cmdName}${args}`,
+            name: commandInfo.name || script,
+            command: `${command} ${script}${args}`,
         };
     }
 }
diff --git a/src/command-parser/expand-npm-wildcard.spec.ts b/src/command-parser/expand-npm-wildcard.spec.ts
index f0a57285..2b772d90 100644
--- a/src/command-parser/expand-npm-wildcard.spec.ts
+++ b/src/command-parser/expand-npm-wildcard.spec.ts
@@ -4,7 +4,8 @@ import { CommandInfo } from '../command';
 import { ExpandNpmWildcard } from './expand-npm-wildcard';
 
 let parser: ExpandNpmWildcard;
-let readPkg: jest.Mock;
+let readPackage: jest.Mock;
+let readDeno: jest.Mock;
 
 const createCommandInfo = (command: string): CommandInfo => ({
     command,
@@ -12,15 +13,43 @@ const createCommandInfo = (command: string): CommandInfo => ({
 });
 
 beforeEach(() => {
-    readPkg = jest.fn();
-    parser = new ExpandNpmWildcard(readPkg);
+    readDeno = jest.fn();
+    readPackage = jest.fn();
+    parser = new ExpandNpmWildcard(readDeno, readPackage);
 });
 
 afterEach(() => {
     jest.restoreAllMocks();
 });
 
-describe('ExpandNpmWildcard#readPackage', () => {
+describe('ExpandWildcard#readDeno', () => {
+    it('can read deno', () => {
+        const expectedDeno = {
+            name: 'deno',
+            version: '1.14.0',
+        };
+        jest.spyOn(fs, 'readFileSync').mockImplementation((path) => {
+            if (path === 'deno.json') {
+                return JSON.stringify(expectedDeno);
+            }
+            return '';
+        });
+
+        const actualReadDeno = ExpandNpmWildcard.readDeno();
+        expect(actualReadDeno).toEqual(expectedDeno);
+    });
+
+    it('can handle errors reading deno', () => {
+        jest.spyOn(fs, 'readFileSync').mockImplementation(() => {
+            throw new Error('Error reading deno');
+        });
+
+        expect(() => ExpandNpmWildcard.readDeno()).not.toThrow();
+        expect(ExpandNpmWildcard.readDeno()).toEqual({});
+    });
+});
+
+describe('ExpandWildcard#readPackage', () => {
     it('can read package', () => {
         const expectedPackage = {
             name: 'concurrently',
@@ -50,46 +79,157 @@ describe('ExpandNpmWildcard#readPackage', () => {
 it('returns same command if not an npm run command', () => {
     const commandInfo = createCommandInfo('npm test');
 
-    expect(readPkg).not.toHaveBeenCalled();
+    expect(readDeno).not.toHaveBeenCalled();
+    expect(readPackage).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+it('returns same command if not a deno task command', () => {
+    const commandInfo = createCommandInfo('deno run');
+
+    expect(readDeno).not.toHaveBeenCalled();
+    expect(readPackage).not.toHaveBeenCalled();
     expect(parser.parse(commandInfo)).toBe(commandInfo);
 });
 
 it('returns same command if no wildcard present', () => {
     const commandInfo = createCommandInfo('npm run foo bar');
 
-    expect(readPkg).not.toHaveBeenCalled();
+    expect(readPackage).not.toHaveBeenCalled();
     expect(parser.parse(commandInfo)).toBe(commandInfo);
 });
 
 it('expands to nothing if no scripts exist in package.json', () => {
-    readPkg.mockReturnValue({});
+    readPackage.mockReturnValue({});
 
     expect(parser.parse(createCommandInfo('npm run foo-*-baz qux'))).toEqual([]);
 });
 
-describe.each([
-    ['npm', 'run'],
-    ['yarn', 'run'],
-    ['pnpm', 'run'],
-    ['bun', 'run'],
-    ['node', '--run'],
-])(`with a %s: prefix`, (npmCmd, runCmd) => {
+it('expands to nothing if no tasks exist in deno.json and no scripts exist in package.json', () => {
+    readDeno.mockReturnValue({});
+    readPackage.mockReturnValue({});
+
+    expect(parser.parse(createCommandInfo('deno task foo-*-baz qux'))).toEqual([]);
+});
+
+describe.each(['npm run', 'yarn run', 'pnpm run', 'bun run', 'node --run'])(
+    `with a '%s' prefix`,
+    (command) => {
+        it('expands to all scripts matching pattern', () => {
+            readPackage.mockReturnValue({
+                scripts: {
+                    'foo-bar-baz': '',
+                    'foo--baz': '',
+                },
+            });
+
+            expect(parser.parse(createCommandInfo(`${command} foo-*-baz qux`))).toEqual([
+                { name: 'bar', command: `${command} foo-bar-baz qux` },
+                { name: '', command: `${command} foo--baz qux` },
+            ]);
+        });
+
+        it('uses wildcard match of script as command name', () => {
+            readPackage.mockReturnValue({
+                scripts: {
+                    'watch-js': '',
+                    'watch-css': '',
+                },
+            });
+
+            expect(
+                parser.parse({
+                    name: '',
+                    command: `${command} watch-*`,
+                }),
+            ).toEqual([
+                { name: 'js', command: `${command} watch-js` },
+                { name: 'css', command: `${command} watch-css` },
+            ]);
+        });
+
+        it('uses existing command name as prefix to the wildcard match', () => {
+            readPackage.mockReturnValue({
+                scripts: {
+                    'watch-js': '',
+                    'watch-css': '',
+                },
+            });
+
+            expect(
+                parser.parse({
+                    name: 'w:',
+                    command: `${command} watch-*`,
+                }),
+            ).toEqual([
+                { name: 'w:js', command: `${command} watch-js` },
+                { name: 'w:css', command: `${command} watch-css` },
+            ]);
+        });
+
+        it('allows negation', () => {
+            readPackage.mockReturnValue({
+                scripts: {
+                    'lint:js': '',
+                    'lint:ts': '',
+                    'lint:fix:js': '',
+                    'lint:fix:ts': '',
+                },
+            });
+
+            expect(parser.parse(createCommandInfo(`${command} lint:*(!fix)`))).toEqual([
+                { name: 'js', command: `${command} lint:js` },
+                { name: 'ts', command: `${command} lint:ts` },
+            ]);
+        });
+
+        it('caches scripts upon calls', () => {
+            readPackage.mockReturnValue({});
+
+            parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+            parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+
+            expect(readPackage).toHaveBeenCalledTimes(1);
+        });
+
+        it("doesn't read deno.json", () => {
+            readPackage.mockReturnValue({});
+
+            parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+
+            expect(readDeno).not.toHaveBeenCalled();
+        });
+    },
+);
+
+describe(`with a 'deno task' prefix`, () => {
     it('expands to all scripts matching pattern', () => {
-        readPkg.mockReturnValue({
-            scripts: {
+        readDeno.mockReturnValue({
+            tasks: {
                 'foo-bar-baz': '',
                 'foo--baz': '',
             },
         });
+        readPackage.mockReturnValue({
+            scripts: {
+                'foo-foo-baz': '',
+            },
+        });
 
-        expect(parser.parse(createCommandInfo(`${npmCmd} ${runCmd} foo-*-baz qux`))).toEqual([
-            { name: 'bar', command: `${npmCmd} ${runCmd} foo-bar-baz qux` },
-            { name: '', command: `${npmCmd} ${runCmd} foo--baz qux` },
+        expect(parser.parse(createCommandInfo(`deno task foo-*-baz qux`))).toEqual([
+            { name: 'bar', command: `deno task foo-bar-baz qux` },
+            { name: '', command: `deno task foo--baz qux` },
+            { name: 'foo', command: `deno task foo-foo-baz qux` },
         ]);
     });
 
     it('uses wildcard match of script as command name', () => {
-        readPkg.mockReturnValue({
+        readDeno.mockReturnValue({
+            tasks: {
+                'watch-sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
             scripts: {
                 'watch-js': '',
                 'watch-css': '',
@@ -99,16 +239,22 @@ describe.each([
         expect(
             parser.parse({
                 name: '',
-                command: `${npmCmd} ${runCmd} watch-*`,
+                command: `deno task watch-*`,
             }),
         ).toEqual([
-            { name: 'js', command: `${npmCmd} ${runCmd} watch-js` },
-            { name: 'css', command: `${npmCmd} ${runCmd} watch-css` },
+            { name: 'sass', command: `deno task watch-sass` },
+            { name: 'js', command: `deno task watch-js` },
+            { name: 'css', command: `deno task watch-css` },
         ]);
     });
 
     it('uses existing command name as prefix to the wildcard match', () => {
-        readPkg.mockReturnValue({
+        readDeno.mockReturnValue({
+            tasks: {
+                'watch-sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
             scripts: {
                 'watch-js': '',
                 'watch-css': '',
@@ -118,16 +264,23 @@ describe.each([
         expect(
             parser.parse({
                 name: 'w:',
-                command: `${npmCmd} ${runCmd} watch-*`,
+                command: `deno task watch-*`,
             }),
         ).toEqual([
-            { name: 'w:js', command: `${npmCmd} ${runCmd} watch-js` },
-            { name: 'w:css', command: `${npmCmd} ${runCmd} watch-css` },
+            { name: 'w:sass', command: `deno task watch-sass` },
+            { name: 'w:js', command: `deno task watch-js` },
+            { name: 'w:css', command: `deno task watch-css` },
         ]);
     });
 
     it('allows negation', () => {
-        readPkg.mockReturnValue({
+        readDeno.mockReturnValue({
+            tasks: {
+                'lint:sass': '',
+                'lint:fix:sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
             scripts: {
                 'lint:js': '',
                 'lint:ts': '',
@@ -136,17 +289,21 @@ describe.each([
             },
         });
 
-        expect(parser.parse(createCommandInfo(`${npmCmd} ${runCmd} lint:*(!fix)`))).toEqual([
-            { name: 'js', command: `${npmCmd} ${runCmd} lint:js` },
-            { name: 'ts', command: `${npmCmd} ${runCmd} lint:ts` },
+        expect(parser.parse(createCommandInfo(`deno task lint:*(!fix)`))).toEqual([
+            { name: 'sass', command: `deno task lint:sass` },
+            { name: 'js', command: `deno task lint:js` },
+            { name: 'ts', command: `deno task lint:ts` },
         ]);
     });
 
     it('caches scripts upon calls', () => {
-        readPkg.mockReturnValue({});
-        parser.parse(createCommandInfo(`${npmCmd} run foo-*-baz qux`));
-        parser.parse(createCommandInfo(`${npmCmd} run foo-*-baz qux`));
+        readDeno.mockReturnValue({});
+        readPackage.mockReturnValue({});
+
+        parser.parse(createCommandInfo(`deno task foo-*-baz qux`));
+        parser.parse(createCommandInfo(`deno task foo-*-baz qux`));
 
-        expect(readPkg).toHaveBeenCalledTimes(1);
+        expect(readDeno).toHaveBeenCalledTimes(1);
+        expect(readPackage).toHaveBeenCalledTimes(1);
     });
 });
diff --git a/src/command-parser/expand-npm-wildcard.ts b/src/command-parser/expand-npm-wildcard.ts
index dc55451b..ce0caa89 100644
--- a/src/command-parser/expand-npm-wildcard.ts
+++ b/src/command-parser/expand-npm-wildcard.ts
@@ -7,10 +7,20 @@ import { CommandParser } from './command-parser';
 const OMISSION = /\(!([^)]+)\)/;
 
 /**
- * Finds wildcards in npm/yarn/pnpm/bun run commands and replaces them with all matching scripts in the
- * `package.json` file of the current directory.
+ * Finds wildcards in 'npm/yarn/pnpm/bun run', 'node --run' and 'deno task'
+ * commands and replaces them with all matching scripts in the `package.json`
+ * and `deno.json` files of the current directory.
  */
 export class ExpandNpmWildcard implements CommandParser {
+    static readDeno() {
+        try {
+            const json = fs.readFileSync('deno.json', { encoding: 'utf-8' });
+            return JSON.parse(json);
+        } catch (e) {
+            return {};
+        }
+    }
+
     static readPackage() {
         try {
             const json = fs.readFileSync('package.json', { encoding: 'utf-8' });
@@ -20,53 +30,77 @@ export class ExpandNpmWildcard implements CommandParser {
         }
     }
 
-    private scripts?: string[];
+    private packageScripts?: string[];
+    private denoTasks?: string[];
+
+    constructor(
+        private readonly readDeno = ExpandNpmWildcard.readDeno,
+        private readonly readPackage = ExpandNpmWildcard.readPackage,
+    ) {}
+
+    private relevantScripts(command: string): string[] {
+        if (!this.packageScripts) {
+            this.packageScripts = Object.keys(this.readPackage().scripts || {});
+        }
 
-    constructor(private readonly readPackage = ExpandNpmWildcard.readPackage) {}
+        if (command === 'deno task') {
+            if (!this.denoTasks) {
+                // If Deno tries to run a task that doesn't exist,
+                // it can fall back to running a script with the same name.
+                // Therefore, the actual list of tasks is the union of the tasks and scripts.
+                this.denoTasks = [
+                    ...Object.keys(this.readDeno().tasks || {}),
+                    ...this.packageScripts,
+                ];
+            }
+
+            return this.denoTasks;
+        }
+
+        return this.packageScripts;
+    }
 
     parse(commandInfo: CommandInfo) {
-        const [, npmCmd, runCmd, cmdName, args] =
-            commandInfo.command.match(/(node|npm|yarn|pnpm|bun) ((?:--)?run) (\S+)([^&]*)/) || [];
-        const wildcardPosition = (cmdName || '').indexOf('*');
+        // We expect one of the following patterns:
+        // - <npm|yarn|pnpm|bun> run <script> [args]
+        // - node --run <script> [args]
+        // - deno task <script> [args]
+        const [, command, scriptGlob, args] =
+            /((?:npm|yarn|pnpm|bun) (?:run)|node --run|deno task) (\S+)([^&]*)/.exec(
+                commandInfo.command,
+            ) || [];
+
+        const wildcardPosition = (scriptGlob || '').indexOf('*');
 
         // If the regex didn't match an npm script, or it has no wildcard,
         // then we have nothing to do here
-        if (!cmdName || wildcardPosition === -1) {
+        if (wildcardPosition === -1) {
             return commandInfo;
         }
 
-        if (!this.scripts) {
-            this.scripts = Object.keys(this.readPackage().scripts || {});
-        }
-
-        const omissionRegex = cmdName.match(OMISSION);
-        const cmdNameSansOmission = cmdName.replace(OMISSION, '');
-        const preWildcard = _.escapeRegExp(cmdNameSansOmission.slice(0, wildcardPosition));
-        const postWildcard = _.escapeRegExp(cmdNameSansOmission.slice(wildcardPosition + 1));
+        const [, omission] = OMISSION.exec(scriptGlob) || [];
+        const scriptGlobSansOmission = scriptGlob.replace(OMISSION, '');
+        const preWildcard = _.escapeRegExp(scriptGlobSansOmission.slice(0, wildcardPosition));
+        const postWildcard = _.escapeRegExp(scriptGlobSansOmission.slice(wildcardPosition + 1));
         const wildcardRegex = new RegExp(`^${preWildcard}(.*?)${postWildcard}$`);
-        // If 'commandInfo.name' doesn't match 'cmdName', this means a custom name
+        // If 'commandInfo.name' doesn't match 'scriptGlob', this means a custom name
         // has been specified and thus becomes the prefix (as described in the README).
-        const prefix = commandInfo.name !== cmdName ? commandInfo.name : '';
+        const prefix = commandInfo.name !== scriptGlob ? commandInfo.name : '';
 
-        return this.scripts
+        return this.relevantScripts(command)
             .map((script) => {
-                const match = script.match(wildcardRegex);
-
-                if (omissionRegex) {
-                    const toOmit = script.match(new RegExp(omissionRegex[1]));
-
-                    if (toOmit) {
-                        return;
-                    }
+                if (omission && RegExp(omission).test(script)) {
+                    return;
                 }
 
-                if (match) {
+                const [, match] = wildcardRegex.exec(script) || [];
+                if (match !== undefined) {
                     return {
                         ...commandInfo,
-                        command: `${npmCmd} ${runCmd} ${script}${args}`,
+                        command: `${command} ${script}${args}`,
                         // Will use an empty command name if no prefix has been specified and
                         // the wildcard match is empty, e.g. if `npm:watch-*` matches `npm run watch-`.
-                        name: prefix + match[1],
+                        name: prefix + match,
                     };
                 }
             })

From d0c1a27e89a12d0824943d9c5bfa494c80bae3fb Mon Sep 17 00:00:00 2001
From: Luka Leer <luka.leer@gmail.com>
Date: Fri, 11 Oct 2024 15:01:05 +0200
Subject: [PATCH 2/3] =?UTF-8?q?=F0=9F=9A=9A=20Rename=20shortcut=20and=20wi?=
 =?UTF-8?q?ldcard=20parsers=20to=20clarify=20broader=20use?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Luka Leer <luka.leer@gmail.com>
---
 ...hortcut.spec.ts => expand-shortcut.spec.ts} |  4 ++--
 ...pand-npm-shortcut.ts => expand-shortcut.ts} |  2 +-
 ...ildcard.spec.ts => expand-wildcard.spec.ts} | 18 +++++++++---------
 ...pand-npm-wildcard.ts => expand-wildcard.ts} |  6 +++---
 src/concurrently.ts                            |  8 ++++----
 5 files changed, 19 insertions(+), 19 deletions(-)
 rename src/command-parser/{expand-npm-shortcut.spec.ts => expand-shortcut.spec.ts} (92%)
 rename src/command-parser/{expand-npm-shortcut.ts => expand-shortcut.ts} (95%)
 rename src/command-parser/{expand-npm-wildcard.spec.ts => expand-wildcard.spec.ts} (94%)
 rename src/command-parser/{expand-npm-wildcard.ts => expand-wildcard.ts} (95%)

diff --git a/src/command-parser/expand-npm-shortcut.spec.ts b/src/command-parser/expand-shortcut.spec.ts
similarity index 92%
rename from src/command-parser/expand-npm-shortcut.spec.ts
rename to src/command-parser/expand-shortcut.spec.ts
index c43b984d..5cbb8d3a 100644
--- a/src/command-parser/expand-npm-shortcut.spec.ts
+++ b/src/command-parser/expand-shortcut.spec.ts
@@ -1,7 +1,7 @@
 import { CommandInfo } from '../command';
-import { ExpandNpmShortcut } from './expand-npm-shortcut';
+import { ExpandShortcut } from './expand-shortcut';
 
-const parser = new ExpandNpmShortcut();
+const parser = new ExpandShortcut();
 
 const createCommandInfo = (command: string, name = ''): CommandInfo => ({
     name,
diff --git a/src/command-parser/expand-npm-shortcut.ts b/src/command-parser/expand-shortcut.ts
similarity index 95%
rename from src/command-parser/expand-npm-shortcut.ts
rename to src/command-parser/expand-shortcut.ts
index 7395c8c8..872bdc97 100644
--- a/src/command-parser/expand-npm-shortcut.ts
+++ b/src/command-parser/expand-shortcut.ts
@@ -13,7 +13,7 @@ import { CommandParser } from './command-parser';
  * | `node:<script>` | `node --run <script>` |
  * | `deno:<script>` | `deno task <script>`  |
  */
-export class ExpandNpmShortcut implements CommandParser {
+export class ExpandShortcut implements CommandParser {
     parse(commandInfo: CommandInfo) {
         const [, prefix, script, args] =
             /^(npm|yarn|pnpm|bun|node|deno):(\S+)(.*)/.exec(commandInfo.command) || [];
diff --git a/src/command-parser/expand-npm-wildcard.spec.ts b/src/command-parser/expand-wildcard.spec.ts
similarity index 94%
rename from src/command-parser/expand-npm-wildcard.spec.ts
rename to src/command-parser/expand-wildcard.spec.ts
index 2b772d90..93cd58dd 100644
--- a/src/command-parser/expand-npm-wildcard.spec.ts
+++ b/src/command-parser/expand-wildcard.spec.ts
@@ -1,9 +1,9 @@
 import fs from 'fs';
 
 import { CommandInfo } from '../command';
-import { ExpandNpmWildcard } from './expand-npm-wildcard';
+import { ExpandWildcard } from './expand-wildcard';
 
-let parser: ExpandNpmWildcard;
+let parser: ExpandWildcard;
 let readPackage: jest.Mock;
 let readDeno: jest.Mock;
 
@@ -15,7 +15,7 @@ const createCommandInfo = (command: string): CommandInfo => ({
 beforeEach(() => {
     readDeno = jest.fn();
     readPackage = jest.fn();
-    parser = new ExpandNpmWildcard(readDeno, readPackage);
+    parser = new ExpandWildcard(readDeno, readPackage);
 });
 
 afterEach(() => {
@@ -35,7 +35,7 @@ describe('ExpandWildcard#readDeno', () => {
             return '';
         });
 
-        const actualReadDeno = ExpandNpmWildcard.readDeno();
+        const actualReadDeno = ExpandWildcard.readDeno();
         expect(actualReadDeno).toEqual(expectedDeno);
     });
 
@@ -44,8 +44,8 @@ describe('ExpandWildcard#readDeno', () => {
             throw new Error('Error reading deno');
         });
 
-        expect(() => ExpandNpmWildcard.readDeno()).not.toThrow();
-        expect(ExpandNpmWildcard.readDeno()).toEqual({});
+        expect(() => ExpandWildcard.readDeno()).not.toThrow();
+        expect(ExpandWildcard.readDeno()).toEqual({});
     });
 });
 
@@ -62,7 +62,7 @@ describe('ExpandWildcard#readPackage', () => {
             return '';
         });
 
-        const actualReadPackage = ExpandNpmWildcard.readPackage();
+        const actualReadPackage = ExpandWildcard.readPackage();
         expect(actualReadPackage).toEqual(expectedPackage);
     });
 
@@ -71,8 +71,8 @@ describe('ExpandWildcard#readPackage', () => {
             throw new Error('Error reading package');
         });
 
-        expect(() => ExpandNpmWildcard.readPackage()).not.toThrow();
-        expect(ExpandNpmWildcard.readPackage()).toEqual({});
+        expect(() => ExpandWildcard.readPackage()).not.toThrow();
+        expect(ExpandWildcard.readPackage()).toEqual({});
     });
 });
 
diff --git a/src/command-parser/expand-npm-wildcard.ts b/src/command-parser/expand-wildcard.ts
similarity index 95%
rename from src/command-parser/expand-npm-wildcard.ts
rename to src/command-parser/expand-wildcard.ts
index ce0caa89..1a44685f 100644
--- a/src/command-parser/expand-npm-wildcard.ts
+++ b/src/command-parser/expand-wildcard.ts
@@ -11,7 +11,7 @@ const OMISSION = /\(!([^)]+)\)/;
  * commands and replaces them with all matching scripts in the `package.json`
  * and `deno.json` files of the current directory.
  */
-export class ExpandNpmWildcard implements CommandParser {
+export class ExpandWildcard implements CommandParser {
     static readDeno() {
         try {
             const json = fs.readFileSync('deno.json', { encoding: 'utf-8' });
@@ -34,8 +34,8 @@ export class ExpandNpmWildcard implements CommandParser {
     private denoTasks?: string[];
 
     constructor(
-        private readonly readDeno = ExpandNpmWildcard.readDeno,
-        private readonly readPackage = ExpandNpmWildcard.readPackage,
+        private readonly readDeno = ExpandWildcard.readDeno,
+        private readonly readPackage = ExpandWildcard.readPackage,
     ) {}
 
     private relevantScripts(command: string): string[] {
diff --git a/src/concurrently.ts b/src/concurrently.ts
index e507343d..30a9fbfe 100644
--- a/src/concurrently.ts
+++ b/src/concurrently.ts
@@ -14,8 +14,8 @@ import {
 } from './command';
 import { CommandParser } from './command-parser/command-parser';
 import { ExpandArguments } from './command-parser/expand-arguments';
-import { ExpandNpmShortcut } from './command-parser/expand-npm-shortcut';
-import { ExpandNpmWildcard } from './command-parser/expand-npm-wildcard';
+import { ExpandShortcut } from './command-parser/expand-shortcut';
+import { ExpandWildcard } from './command-parser/expand-wildcard';
 import { StripQuotes } from './command-parser/strip-quotes';
 import { CompletionListener, SuccessCondition } from './completion-listener';
 import { FlowController } from './flow-control/flow-controller';
@@ -175,8 +175,8 @@ export function concurrently(
 
     const commandParsers: CommandParser[] = [
         new StripQuotes(),
-        new ExpandNpmShortcut(),
-        new ExpandNpmWildcard(),
+        new ExpandShortcut(),
+        new ExpandWildcard(),
     ];
 
     if (options.additionalArguments) {

From 9f7dad22841da7c2210ebfa9bb0102749a0db74b Mon Sep 17 00:00:00 2001
From: Luka Leer <luka.leer@gmail.com>
Date: Sun, 13 Oct 2024 18:04:25 +0200
Subject: [PATCH 3/3] =?UTF-8?q?=F0=9F=92=A1=20Add=20comment=20that=20expla?=
 =?UTF-8?q?ins=20the=20OMISSION=20RegEx?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Luka Leer <luka.leer@gmail.com>
---
 src/command-parser/expand-wildcard.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/command-parser/expand-wildcard.ts b/src/command-parser/expand-wildcard.ts
index 1a44685f..810750f3 100644
--- a/src/command-parser/expand-wildcard.ts
+++ b/src/command-parser/expand-wildcard.ts
@@ -4,6 +4,7 @@ import _ from 'lodash';
 import { CommandInfo } from '../command';
 import { CommandParser } from './command-parser';
 
+// Matches a negative filter surrounded by '(!' and ')'.
 const OMISSION = /\(!([^)]+)\)/;
 
 /**