lint-staged 15.5.2 → 16.1.0

package/MIGRATION.md

@@ -0,0 +1,70 @@
+## v16
+
+#### Updated Node.js version requirement
+
+The lowest supported Node.js version is `18.19.0` or `20.5.0`, following requirements of `execa@9`. Please upgrade your Node.js version.
+
+#### Removed validation for removed advanced configuration file options
+
+Advanced configuration options (removed in v9) are no longer validated separately, and might be treated as valid globs for tasks. Please do not try to use advanced config options anymore, they haven't been supported since v8.
+
+#### Removed the `--shell` option
+
+The `--shell` flag has been removed and _lint-staged_ no longer supports evaluating commands directly via a shell. To migrate existing commands, you can create a shell script and invoke it instead. Lint-staged will pass matched staged files as a list of arguments, accessible via `"$@"`:
+
+```shell
+# my-script.sh
+#!/bin/bash
+
+echo "Staged files: $@"
+```
+
+and
+
+```json
+{ "*.js": "my-script.sh" }
+```
+
+If you were using the shell option to avoid passing filenames to tasks, for example `bash -c 'tsc --noEmit'`, use the function syntax instead:
+
+```js
+export default { '*.ts': () => 'tsc --noEmit' }
+```
+
+#### Processes are spawned using `nano-spawn`
+
+Processes are spawned using [nano-spawn](https://github.com/sindresorhus/nano-spawn) instead of [execa](https://github.com/sindresorhus/execa). If you are using Node.js scripts as tasks, you might need to explicitly run them with `node`, especially when using Windows:
+
+```json
+{
+  "*.js": "node my-js-linter.js"
+}
+```
+
+## v15
+
+- Since `v15.0.0` _lint-staged_ no longer supports Node.js 16. Please upgrade your Node.js version to at least `18.12.0`.
+
+## v14
+
+- Since `v14.0.0` _lint-staged_ no longer supports Node.js 14. Please upgrade your Node.js version to at least `16.14.0`.
+
+## v13
+
+- Since `v13.0.0` _lint-staged_ no longer supports Node.js 12. Please upgrade your Node.js version to at least `14.13.1`, or `16.0.0` onward.
+- Version `v13.3.0` was incorrectly released including code of version `v14.0.0`. This means the breaking changes of `v14` are also included in `v13.3.0`, the last `v13` version released
+
+## v12
+
+- Since `v12.0.0` _lint-staged_ is a pure ESM module, so make sure your Node.js version is at least `12.20.0`, `14.13.1`, or `16.0.0`. Read more about ESM modules from the official [Node.js Documentation site here](https://nodejs.org/api/esm.html#introduction).
+
+## v10
+
+- From `v10.0.0` onwards any new modifications to originally staged files will be automatically added to the commit.
+  If your task previously contained a `git add` step, please remove this.
+  The automatic behaviour ensures there are less race-conditions,
+  since trying to run multiple git operations at the same time usually results in an error.
+- From `v10.0.0` onwards, lint-staged uses git stashes to improve speed and provide backups while running.
+  Since git stashes require at least an initial commit, you shouldn't run lint-staged in an empty repo.
+- From `v10.0.0` onwards, lint-staged requires Node.js version 10.13.0 or later.
+- From `v10.0.0` onwards, lint-staged will abort the commit if linter tasks undo all staged changes. To allow creating an empty commit, please use the `--allow-empty` option.

package/README.md

@@ -34,13 +34,28 @@ $ git commit
 
 </details>
 
+## Table of Contents
+
+- [Why](#why)
+- [Installation and setup](#installation-and-setup)
+- [Changelog](#changelog)
+- [Command line flags](#command-line-flags)
+- [Configuration](#configuration)
+- [Filtering files](#filtering-files)
+- [What commands are supported?](#what-commands-are-supported)
+- [Running multiple commands in a sequence](#running-multiple-commands-in-a-sequence)
+- [Using JS configuration files](#using-js-configuration-files)
+- [Reformatting the code](#reformatting-the-code)
+- [Examples](#examples)
+- [Frequently Asked Questions](#frequently-asked-questions)
+
 ## Why
 
 Code quality tasks like formatters and linters make more sense when run before committing your code. By doing so you can ensure no errors go into the repository and enforce code style. But running a task on a whole project can be slow, and opinionated tasks such as linting can sometimes produce irrelevant results. Ultimately you only want to check files that will be committed.
 
 This project contains a script that will run arbitrary shell tasks with a list of staged files as an argument, filtered by a specified glob pattern.
 
-## Related blog posts and talks
+### Related blog posts and talks
 
 - [Introductory Medium post - Andrey Okonetchnikov, 2016](https://medium.com/@okonetchnikov/make-linting-great-again-f3890e1ad6b8#.8qepn2b5l)
 - [Running Jest Tests Before Each Git Commit - Ben McCormick, 2017](https://benmccormick.org/2017/02/26/running-jest-tests-before-each-git-commit/)
@@ -70,7 +85,7 @@ Now change a few files, `git add` or `git add --patch` some of them to your comm
 
 See [examples](#examples) and [configuration](#configuration) for more information.
 
-> [!CAUTION]  
+> [!CAUTION]
 > _Lint-staged_ runs `git` operations affecting the files in your repository. By default _lint-staged_ creates a `git stash` as a backup of the original state before running any configured tasks to help prevent data loss.
 
 ## Changelog
@@ -79,33 +94,7 @@ See [Releases](https://github.com/okonet/lint-staged/releases).
 
 ### Migration
 
-#### v15
-
-- Since `v15.0.0` _lint-staged_ no longer supports Node.js 16. Please upgrade your Node.js version to at least `18.12.0`.
-
-#### v14
-
-- Since `v14.0.0` _lint-staged_ no longer supports Node.js 14. Please upgrade your Node.js version to at least `16.14.0`.
-
-#### v13
-
-- Since `v13.0.0` _lint-staged_ no longer supports Node.js 12. Please upgrade your Node.js version to at least `14.13.1`, or `16.0.0` onward.
-- Version `v13.3.0` was incorrectly released including code of version `v14.0.0`. This means the breaking changes of `v14` are also included in `v13.3.0`, the last `v13` version released
-
-#### v12
-
-- Since `v12.0.0` _lint-staged_ is a pure ESM module, so make sure your Node.js version is at least `12.20.0`, `14.13.1`, or `16.0.0`. Read more about ESM modules from the official [Node.js Documentation site here](https://nodejs.org/api/esm.html#introduction).
-
-#### v10
-
-- From `v10.0.0` onwards any new modifications to originally staged files will be automatically added to the commit.
-  If your task previously contained a `git add` step, please remove this.
-  The automatic behaviour ensures there are less race-conditions,
-  since trying to run multiple git operations at the same time usually results in an error.
-- From `v10.0.0` onwards, lint-staged uses git stashes to improve speed and provide backups while running.
-  Since git stashes require at least an initial commit, you shouldn't run lint-staged in an empty repo.
-- From `v10.0.0` onwards, lint-staged requires Node.js version 10.13.0 or later.
-- From `v10.0.0` onwards, lint-staged will abort the commit if linter tasks undo all staged changes. To allow creating an empty commit, please use the `--allow-empty` option.
+For breaking changes, see [MIGRATION.md](./MIGRATION.md).
 
 ## Command line flags
 
@@ -120,17 +109,15 @@ Options:
   -c, --config [path]                path to configuration file, or - to read from stdin
   --cwd [path]                       run all tasks in specific directory, instead of the current
   -d, --debug                        print additional debug information (default: false)
-  --diff [string]                    override the default "--staged" flag of "git diff" to get list of files.
-                                     Implies "--no-stash".
-  --diff-filter [string]             override the default "--diff-filter=ACMR" flag of "git diff" to get list of
-                                     files
+  --diff [string]                    override the default "--staged" flag of "git diff" to get list of files. Implies
+                                     "--no-stash".
+  --diff-filter [string]             override the default "--diff-filter=ACMR" flag of "git diff" to get list of files
   --max-arg-length [number]          maximum length of the command-line argument string (default: 0)
-  --no-stash                         disable the backup stash, and do not revert in case of errors. Implies
-                                     "--no-hide-partially-staged".
+  --no-revert                        do not revert to original state in case of errors.
+  --no-stash                         disable the backup stash. Implies "--no-revert".
   --no-hide-partially-staged         disable hiding unstaged changes from partially staged files
   -q, --quiet                        disable lint-staged’s own console output (default: false)
   -r, --relative                     pass relative filepaths to tasks (default: false)
-  -x, --shell [path]                 skip parsing of tasks for better shell support (default: false)
   -v, --verbose                      show task output even when tasks succeed; by default only failed output is
                                      shown (default: false)
   -h, --help                         display help for command
@@ -156,11 +143,11 @@ Any lost modifications can be restored from a git stash:
 - **`--diff`**: By default tasks are filtered against all files staged in git, generated from `git diff --staged`. This option allows you to override the `--staged` flag with arbitrary revisions. For example to get a list of changed files between two branches, use `--diff="branch1...branch2"`. You can also read more from about [git diff](https://git-scm.com/docs/git-diff) and [gitrevisions](https://git-scm.com/docs/gitrevisions). This option also implies `--no-stash`.
 - **`--diff-filter`**: By default only files that are _added_, _copied_, _modified_, or _renamed_ are included. Use this flag to override the default `ACMR` value with something else: _added_ (`A`), _copied_ (`C`), _deleted_ (`D`), _modified_ (`M`), _renamed_ (`R`), _type changed_ (`T`), _unmerged_ (`U`), _unknown_ (`X`), or _pairing broken_ (`B`). See also the `git diff` docs for [--diff-filter](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203).
 - **`--max-arg-length`**: long commands (a lot of files) are automatically split into multiple chunks when it detects the current shell cannot handle them. Use this flag to override the maximum length of the generated command string.
-- **`--no-stash`**: By default a backup stash will be created before running the tasks, and all task modifications will be reverted in case of an error. This option will disable creating the stash, and instead leave all modifications in the index when aborting the commit. Can be re-enabled with `--stash`. This option also implies `--no-hide-partially-staged`.
+- **`--no-stash`**: By default a backup stash will be created before running the tasks, and all task modifications will be reverted in case of an error. This option will disable creating the stash, and instead leave all modifications in the index when aborting the commit. This option also implies `--no-hide-partially-staged`.
 - **`--no-hide-partially-staged`**: By default, unstaged changes from partially staged files will be hidden. This option will disable this behavior and include all unstaged changes in partially staged files. Can be re-enabled with `--hide-partially-staged`
 - **`--quiet`**: Supress all CLI output, except from tasks.
 - **`--relative`**: Pass filepaths relative to `process.cwd()` (where `lint-staged` runs) to tasks. Default is `false`.
-- **`--shell`**: By default task commands will be parsed for speed and security. This has the side-effect that regular shell scripts might not work as expected. You can skip parsing of commands with this option. To use a specific shell, use a path like `--shell "/bin/bash"`.
+- **`--no-revert`**: By default all task modifications will be reverted in case of an error. This option will disable the behavior, and apply task modifications to the index before aborting the commit.
 - **`--verbose`**: Show task output even when tasks succeed. By default only failed output is shown.
 
 ## Configuration
@@ -180,7 +167,7 @@ _Lint-staged_ can be configured in many ways:
   whether your project's _package.json_ contains the `"type": "module"` option or not.
 - Pass a configuration file using the `--config` or `-c` flag
 
-Configuration should be an object where each value is a command to run and its key is a glob pattern to use for this command. This package uses [micromatch](https://github.com/micromatch/micromatch) for glob patterns. JavaScript files can also export advanced configuration as a function. See [Using JS configuration files](#using-js-configuration-files) for more info.
+Configuration should be an object where each value is a **command** to run and its key is a glob pattern to use for this command. This package uses [micromatch](https://github.com/micromatch/micromatch) for glob patterns. JavaScript files can also export advanced configuration as a function. See [Using JS configuration files](#using-js-configuration-files) for more info.
 
 You can also place multiple configuration files in different directories inside a project. For a given staged file, the closest configuration file will always be used. See ["How to use `lint-staged` in a multi-package monorepo?"](#how-to-use-lint-staged-in-a-multi-package-monorepo) for more info and an example.
 
@@ -363,12 +350,19 @@ export default {
 
 This will result in _lint-staged_ first running `eslint .` (matching _all_ files), and if it passes, `prettier --write file-1.js file-2.js`, when you have staged files `file-1.js`, `file-2.js` and `README.md`.
 
-### Function signature
+### JavaScript Functions
 
-The function can also be async:
+You can also configure _lint-staged_ to run a JavaScript/Node.js script directly, passing the list of staged files as an argument:
 
-```ts
-(filenames: string[]) => string | string[] | Promise<string | string[]>
+```js
+export default {
+  '*.js': {
+    title: 'Log staged JS files to console',
+    task: async (files) => {
+      console.log('Staged JS files:', files)
+    },
+  },
+}
 ```
 
 ### Example: Export a function to build your own matchers
@@ -777,7 +771,6 @@ const success = await lintStaged({
   maxArgLength: null,
   quiet: false,
   relative: false,
-  shell: false,
   stash: true,
   verbose: false,
 })
@@ -795,7 +788,6 @@ const success = await lintStaged({
   maxArgLength: null,
   quiet: false,
   relative: false,
-  shell: false,
   stash: true,
   verbose: false,
 })
@@ -1021,27 +1013,19 @@ ESLint v8.51.0 introduced [`--no-warn-ignored` CLI flag](https://eslint.org/docs
 
 When running `lint-staged` via Husky hooks, TypeScript may ignore `tsconfig.json`, leading to errors like:
 
-> **TS17004:** Cannot use JSX unless the '--jsx' flag is provided.  
-> **TS1056:** Accessors are only available when targeting ECMAScript 5 and higher.  
-
-See issue [#825](https://github.com/okonet/lint-staged/issues/825) for more details.  
-
-#### Root Cause  
-
-<details>
-  <summary>Click to expand</summary>
+> **TS17004:** Cannot use JSX unless the '--jsx' flag is provided.
+> **TS1056:** Accessors are only available when targeting ECMAScript 5 and higher.
 
-1. `lint-staged` automatically passes matched staged files as arguments to commands.  
-2. Certain input files can cause TypeScript to ignore `tsconfig.json`. For more details, see this TypeScript issue: [Allow tsconfig.json when input files are specified](https://github.com/microsoft/TypeScript/issues/27379).  
+See issue [#825](https://github.com/okonet/lint-staged/issues/825) for more details.
 
-</details>  
+#### Root Cause
 
-#### Workaround 1: Use a [function signature](https://github.com/lint-staged/lint-staged?tab=readme-ov-file#example-run-tsc-on-changes-to-typescript-files-but-do-not-pass-any-filename-arguments) for the `tsc` command
+1. `lint-staged` automatically passes matched staged files as arguments to commands.
+2. Certain input files can cause TypeScript to ignore `tsconfig.json`. For more details, see this TypeScript issue: [Allow tsconfig.json when input files are specified](https://github.com/microsoft/TypeScript/issues/27379).
 
-<details>
-  <summary>Click to expand</summary>
+#### Workaround: Use a [function signature](https://github.com/lint-staged/lint-staged?tab=readme-ov-file#example-run-tsc-on-changes-to-typescript-files-but-do-not-pass-any-filename-arguments) for the `tsc` command
 
-As suggested by @antoinerousseau in [#825 (comment)](https://github.com/lint-staged/lint-staged/issues/825#issuecomment-620018284), using a function prevents `lint-staged` from appending file arguments:  
+As suggested by @antoinerousseau in [#825 (comment)](https://github.com/lint-staged/lint-staged/issues/825#issuecomment-620018284), using a function prevents `lint-staged` from appending file arguments:
 
 **Before:**
 
@@ -1061,50 +1045,8 @@ As suggested by @antoinerousseau in [#825 (comment)](https://github.com/lint-sta
 ```js
 // lint-staged.config.js
 module.exports = {
-  "*.{ts,tsx}": [
-    () => "tsc --noEmit", 
-    "prettier --write"
-  ],
+  '*.{ts,tsx}': [() => 'tsc --noEmit', 'prettier --write'],
 }
 ```
 
 </details>
-
-#### Workaround 2: Take the `sh` or `bash` to wrap the `tsc` command
-
-<details>
-  <summary>Click to expand</summary>
-
-As suggested by @sombreroEnPuntas in [#825 (comment)](https://github.com/lint-staged/lint-staged/issues/825#issuecomment-674575655), wrapping `tsc` in a shell command prevents `lint-staged` from modifying its arguments:
-
-**Before:**
-
-```js
-// package.json
-
-"lint-staged": {
-  "*.{ts,tsx}":[
-    "tsc --noEmit",
-    "prettier --write"
-  ]
-}
-```
-
-**After:**
-
-```js
-// package.json
-
-"lint-staged": {
-  "*.{ts,tsx}":[
-    "bash -c 'tsc --noEmit'"
-    "prettier --write"
-  ]
-}
-```
-
-**Note:** This approach may have cross-platform compatibility issues.
-
-</details>
-
-</details>

package/bin/lint-staged.js

@@ -61,30 +61,26 @@ program.option(
 program.option('--max-arg-length [number]', 'maximum length of the command-line argument string', 0)
 
 /**
- * We don't want to show the `--stash` flag because it's on by default, and only show the
- * negatable flag `--no-stash` in stead. There seems to be a bug in Commander.js where
+ * We don't want to show the `--revert` flag because it's on by default, and only show the
+ * negatable flag `--no-rever` instead. There seems to be a bug in Commander.js where
  * configuring only the latter won't actually set the default value.
  */
 program
   .addOption(
-    new Option('--stash', 'enable the backup stash, and revert in case of errors')
-      .default(true)
-      .hideHelp()
+    new Option('--revert', 'revert to original state in case of errors').default(true).hideHelp()
   )
   .addOption(
-    new Option(
-      '--no-stash',
-      'disable the backup stash, and do not revert in case of errors. Implies "--no-hide-partially-staged".'
-    )
+    new Option('--no-revert', 'do not revert to original state in case of errors.').default(false)
+  )
+
+program
+  .addOption(new Option('--stash', 'enable the backup stash').default(true).hideHelp())
+  .addOption(
+    new Option('--no-stash', 'disable the backup stash. Implies "--no-revert".')
       .default(false)
-      .implies({ hidePartiallyStaged: false })
+      .implies({ revert: false, hidePartiallyStaged: false })
   )
 
-/**
- * We don't want to show the `--hide-partially-staged` flag because it's on by default, and only show the
- * negatable flag `--no-hide-partially-staged` in stead. There seems to be a bug in Commander.js where
- * configuring only the latter won't actually set the default value.
- */
 program
   .addOption(
     new Option('--hide-partially-staged', 'hide unstaged changes from partially staged files')
@@ -102,8 +98,6 @@ program.option('-q, --quiet', 'disable lint-staged’s own console output', fals
 
 program.option('-r, --relative', 'pass relative filepaths to tasks', false)
 
-program.option('-x, --shell [path]', 'skip parsing of tasks for better shell support', false)
-
 program.option(
   '-v, --verbose',
   'show task output even when tasks succeed; by default only failed output is shown',
@@ -129,7 +123,7 @@ const options = {
   maxArgLength: cliOptions.maxArgLength || undefined,
   quiet: !!cliOptions.quiet,
   relative: !!cliOptions.relative,
-  shell: cliOptions.shell /* Either a boolean or a string pointing to the shell */,
+  revert: !!cliOptions.revert, // commander inverts `no-<x>` flags to `!x`
   stash: !!cliOptions.stash, // commander inverts `no-<x>` flags to `!x`
   hidePartiallyStaged: !!cliOptions.hidePartiallyStaged, // commander inverts `no-<x>` flags to `!x`
   verbose: !!cliOptions.verbose,

package/lib/execGit.js

@@ -1,5 +1,5 @@
 import debug from 'debug'
-import { execa } from 'execa'
+import spawn, { SubprocessError } from 'nano-spawn'
 
 const debugLog = debug('lint-staged:execGit')
 
@@ -12,17 +12,22 @@ const NO_SUBMODULE_RECURSE = ['-c', 'submodule.recurse=false']
 // exported for tests
 export const GIT_GLOBAL_OPTIONS = [...NO_SUBMODULE_RECURSE]
 
-export const execGit = async (cmd, options = {}) => {
+/** @type {(cmd: string[], options?: import('nano-spawn').Options) => Promise<string>} */
+export const execGit = async (cmd, options) => {
   debugLog('Running git command', cmd)
   try {
-    const { stdout } = await execa('git', GIT_GLOBAL_OPTIONS.concat(cmd), {
+    const result = await spawn('git', [...NO_SUBMODULE_RECURSE, ...cmd], {
       ...options,
-      all: true,
-      cwd: options.cwd || process.cwd(),
+      cwd: options?.cwd ?? process.cwd(),
       stdin: 'ignore',
     })
-    return stdout
-  } catch ({ all }) {
-    throw new Error(all)
+
+    return result.stdout
+  } catch (error) {
+    if (error instanceof SubprocessError) {
+      throw new Error(error.output, { cause: error })
+    }
+
+    throw error
   }
 }

package/lib/getFunctionTask.js

@@ -0,0 +1,38 @@
+import debug from 'debug'
+
+import { makeErr } from './getSpawnedTask.js'
+
+const debugLog = debug('lint-staged:getFunctionTasks')
+
+/**
+ * @typedef {{ title: string; task: Function }} FunctionTask
+ * @type {(commands: FunctionTask|Array<string|Function>|string|Function) => boolean}
+ * @returns `true` if command is a function task
+ */
+export const isFunctionTask = (commands) => typeof commands === 'object' && !Array.isArray(commands)
+
+/**
+ * Handles function configuration and pushes the tasks into the task array
+ *
+ * @param {object} command
+ * @param {Array<string>} files
+ * @throws {Error} If the function configuration is not valid
+ */
+export const getFunctionTask = async (command, files) => {
+  debugLog('Creating Listr tasks for function %o', command)
+
+  const task = async (ctx) => {
+    try {
+      await command.task(files)
+    } catch (e) {
+      throw makeErr(command.title, e, ctx)
+    }
+  }
+
+  return [
+    {
+      title: command.title,
+      task,
+    },
+  ]
+}

package/lib/{resolveTaskFn.js → getSpawnedTask.js}

@@ -1,6 +1,6 @@
 import chalk from 'chalk'
 import debug from 'debug'
-import { execa, execaCommand } from 'execa'
+import spawn from 'nano-spawn'
 import pidTree from 'pidtree'
 import { parseArgsStringToArgv } from 'string-argv'
 
@@ -8,40 +8,27 @@ import { error, info } from './figures.js'
 import { getInitialState } from './state.js'
 import { TaskError } from './symbols.js'
 
-/**
- * @see https://github.com/sindresorhus/execa/blob/f4b8b3ab601c94d1503f1010822952758dcc6350/lib/command.js#L32-L37
- */
-const escapeSpaces = (input) => input.replaceAll(' ', '\\ ')
-
 const TASK_ERROR = 'lint-staged:taskError'
 
-const debugLog = debug('lint-staged:resolveTaskFn')
+const debugLog = debug('lint-staged:getSpawnedTask')
 
-const getTag = ({ code, killed, signal }) => (killed && 'KILLED') || signal || code || 'FAILED'
+/** @type {(error: import('nano-spawn').SubprocessError) => string} */
+const getTag = (error) => {
+  return error.signalName ?? 'FAILED'
+}
 
 /**
  * Handle task console output.
  *
  * @param {string} command
- * @param {Object} result
- * @param {string} result.stdout
- * @param {string} result.stderr
- * @param {boolean} result.failed
- * @param {boolean} result.killed
- * @param {string} result.signal
+ * @param {import('nano-spawn').Result | import('nano-spawn').SubprocessError} result
  * @param {Object} ctx
  * @returns {Error}
  */
 const handleOutput = (command, result, ctx, isError = false) => {
-  const { stderr, stdout } = result
-  const hasOutput = !!stderr || !!stdout
-
-  if (hasOutput) {
+  if (result.output) {
     const outputTitle = isError ? chalk.redBright(`${error} ${command}:`) : `${info} ${command}:`
-    const output = []
-      .concat(ctx.quiet ? [] : ['', outputTitle])
-      .concat(stderr ? stderr : [])
-      .concat(stdout ? stdout : [])
+    const output = [...(ctx.quiet ? [] : ['', outputTitle]), result.output]
     ctx.output.push(output.join('\n'))
   } else if (isError) {
     // Show generic error when task had no output
@@ -52,12 +39,14 @@ const handleOutput = (command, result, ctx, isError = false) => {
 }
 
 /**
- * Kill an execa process along with all its child processes.
- * @param {execa.ExecaChildProcess<string>} execaProcess
+ * Kill subprocess along with all its child processes.
+ * @param {import('nano-spawn').Subprocess} subprocess
  */
-const killExecaProcess = async (execaProcess) => {
+const killSubprocess = async (subprocess) => {
+  const childProcess = await subprocess.nodeChildProcess
+
   try {
-    const childPids = await pidTree(execaProcess.pid)
+    const childPids = await pidTree(childProcess.pid)
     for (const childPid of childPids) {
       try {
         process.kill(childPid)
@@ -68,27 +57,27 @@ const killExecaProcess = async (execaProcess) => {
   } catch (error) {
     // Suppress "No matching pid found" error. This probably means
     // the process already died before executing.
-    debugLog(`Failed to kill process with pid "%d": %o`, execaProcess.pid, error)
+    debugLog(`Failed to kill process with pid "%d": %o`, childProcess.pid, error)
   }
 
-  // The execa process is killed separately in order to get the `KILLED` status.
-  execaProcess.kill()
+  // The child process is terminated separately in order to get the `KILLED` status.
+  childProcess.kill('SIGKILL')
 }
 
 /**
- * Interrupts the execution of the execa process that we spawned if
+ * Interrupts the execution of the subprocess that we spawned if
  * another task adds an error to the context.
  *
  * @param {Object} ctx
- * @param {execa.ExecaChildProcess<string>} execaChildProcess
+ * @param {import('nano-spawn').Subprocess} subprocess
  * @returns {() => Promise<void>} Function that clears the interval that
  * checks the context.
  */
-const interruptExecutionOnError = (ctx, execaChildProcess) => {
+const interruptExecutionOnError = (ctx, subprocess) => {
   let killPromise
 
   const errorListener = async () => {
-    killPromise = killExecaProcess(execaChildProcess)
+    killPromise = killSubprocess(subprocess)
     await killPromise
   }
 
@@ -104,23 +93,18 @@ const interruptExecutionOnError = (ctx, execaChildProcess) => {
  * Create a error output depending on process result.
  *
  * @param {string} command
- * @param {Object} result
- * @param {string} result.stdout
- * @param {string} result.stderr
- * @param {boolean} result.failed
- * @param {boolean} result.killed
- * @param {string} result.signal
+ * @param {import('nano-spawn').SubprocessError} error
  * @param {Object} ctx
  * @returns {Error}
  */
-const makeErr = (command, result, ctx) => {
+export const makeErr = (command, error, ctx) => {
   ctx.errors.add(TaskError)
 
   // https://nodejs.org/api/events.html#error-events
   ctx.events.emit(TASK_ERROR, TaskError)
 
-  handleOutput(command, result, ctx, true)
-  const tag = getTag(result)
+  handleOutput(command, error, ctx, true)
+  const tag = getTag(error)
   return new Error(`${chalk.redBright(command)} ${chalk.dim(`[${tag}]`)}`)
 }
 
@@ -133,53 +117,45 @@ const makeErr = (command, result, ctx) => {
  * @param {String} options.topLevelDir - Current git repo top-level path
  * @param {Boolean} options.isFn - Whether the linter task is a function
  * @param {Array<string>} options.files — Filepaths to run the linter task against
- * @param {Boolean} [options.shell] — Whether to skip parsing linter task for better shell support
  * @param {Boolean} [options.verbose] — Always show task verbose
  * @returns {() => Promise<Array<string>>}
  */
-export const resolveTaskFn = ({
+export const getSpawnedTask = ({
   command,
   cwd = process.cwd(),
   files,
   topLevelDir,
   isFn,
-  shell = false,
   verbose = false,
 }) => {
   const [cmd, ...args] = parseArgsStringToArgv(command)
   debugLog('cmd:', cmd)
   debugLog('args:', args)
 
-  const execaOptions = {
+  const spawnOptions = {
     // Only use topLevelDir as CWD if we are using the git binary
     // e.g `npm` should run tasks in the actual CWD
     cwd: /^git(\.exe)?/i.test(cmd) ? topLevelDir : cwd,
     preferLocal: true,
-    reject: false,
-    shell,
     stdin: 'ignore',
   }
 
-  debugLog('execaOptions:', execaOptions)
+  debugLog('Spawn options:', spawnOptions)
 
   return async (ctx = getInitialState()) => {
-    const execaChildProcess = shell
-      ? execaCommand(
-          isFn ? command : `${command} ${files.map(escapeSpaces).join(' ')}`,
-          execaOptions
-        )
-      : execa(cmd, isFn ? args : args.concat(files), execaOptions)
-
-    const quitInterruptCheck = interruptExecutionOnError(ctx, execaChildProcess)
-    const result = await execaChildProcess
-    await quitInterruptCheck()
-
-    if (result.failed || result.killed || result.signal != null) {
-      throw makeErr(command, result, ctx)
-    }
+    const subprocess = spawn(cmd, isFn ? args : args.concat(files), spawnOptions)
 
-    if (verbose) {
-      handleOutput(command, result, ctx)
+    const quitInterruptCheck = interruptExecutionOnError(ctx, subprocess)
+
+    try {
+      const result = await subprocess
+      if (verbose) {
+        handleOutput(command, result, ctx)
+      }
+    } catch (error) {
+      throw makeErr(command, error, ctx)
+    } finally {
+      await quitInterruptCheck()
     }
   }
 }

package/lib/{makeCmdTasks.js → getSpawnedTasks.js}

@@ -1,9 +1,9 @@
 import debug from 'debug'
 
+import { getSpawnedTask } from './getSpawnedTask.js'
 import { configurationError } from './messages.js'
-import { resolveTaskFn } from './resolveTaskFn.js'
 
-const debugLog = debug('lint-staged:makeCmdTasks')
+const debugLog = debug('lint-staged:getSpawnedTasks')
 
 /**
  * Creates and returns an array of listr tasks which map to the given commands.
@@ -13,14 +13,14 @@ const debugLog = debug('lint-staged:makeCmdTasks')
  * @param {string} options.cwd
  * @param {Array<string>} options.files
  * @param {string} options.topLevelDir
- * @param {Boolean} shell
  * @param {Boolean} verbose
  */
-export const makeCmdTasks = async ({ commands, cwd, files, topLevelDir, shell, verbose }) => {
-  debugLog('Creating listr tasks for commands %o', commands)
-  const commandArray = Array.isArray(commands) ? commands : [commands]
+export const getSpawnedTasks = async ({ commands, cwd, files, topLevelDir, verbose }) => {
+  debugLog('Creating Listr tasks for commands %o', commands)
   const cmdTasks = []
 
+  const commandArray = Array.isArray(commands) ? commands : [commands]
+
   for (const cmd of commandArray) {
     // command function may return array of commands that already include `stagedFiles`
     const isFn = typeof cmd === 'function'
@@ -43,7 +43,7 @@ export const makeCmdTasks = async ({ commands, cwd, files, topLevelDir, shell, v
         )
       }
 
-      const task = resolveTaskFn({ command, cwd, files, topLevelDir, isFn, shell, verbose })
+      const task = getSpawnedTask({ command, cwd, files, topLevelDir, isFn, verbose })
       cmdTasks.push({ title: command, command, task })
     }
   }

package/lib/getStagedFiles.js

@@ -38,10 +38,10 @@ export const getStagedFiles = async ({ cwd = process.cwd(), diff, diffFilter } =
         const [, dstMode, , , ,] = info.split(' ')
 
         /**
-         * Filter out submodule root directory. "160000" is the object mode for submodules.
-         * @see https://github.com/git/git/blob/485f5f863615e670fd97ae40af744e14072cfe18/object.h#L114-L120
+         * Filter out submodules and symlinks
+         * @see https://github.com/git/git/blob/cb96e1697ad6e54d11fc920c95f82977f8e438f8/Documentation/git-fast-import.adoc?plain=1#L634-L646
          */
-        if (dstMode === '160000') {
+        if (dstMode === '160000' || dstMode === '120000') {
           return []
         }
 

package/lib/index.d.ts

@@ -1,12 +1,17 @@
-type SyncFunctionTask = (stagedFileNames: string[]) => string | string[]
+type SyncGenerateTask = (stagedFileNames: string[]) => string | string[]
 
-type AsyncFunctionTask = (stagedFileNames: string[]) => Promise<string | string[]>
+type AsyncGenerateTask = (stagedFileNames: string[]) => Promise<string | string[]>
 
-type FunctionTask = SyncFunctionTask | AsyncFunctionTask
+type GenerateTask = SyncGenerateTask | AsyncGenerateTask
+
+type TaskFunction = {
+  title: string
+  task: (stagedFileNames: string[]) => void | Promise<void>
+}
 
 export type Configuration =
-  | Record<string, string | FunctionTask | (string | FunctionTask)[]>
-  | FunctionTask
+  | Record<string, string | TaskFunction | GenerateTask | (string | GenerateTask)[]>
+  | GenerateTask
 
 export type Options = {
   /**
@@ -62,10 +67,10 @@ export type Options = {
    */
   relative?: boolean
   /**
-   * Skip parsing of tasks for better shell support
-   * @default false
+   * Revert to original state in case of errors
+   * @default true
    */
-  shell?: boolean
+  revert?: boolean
   /**
    * Enable the backup stash, and revert in case of errors.
    * @warn Disabling this also implies `hidePartiallyStaged: false`.

package/lib/index.js

@@ -57,7 +57,7 @@ const getMaxArgLength = () => {
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
- * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
+ * @param {boolean} [options.revert] - revert to original state in case of errors
  * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
  * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
  * @param {Logger} [logger]
@@ -77,9 +77,10 @@ const lintStaged = async (
     maxArgLength = getMaxArgLength() / 2,
     quiet = false,
     relative = false,
-    shell = false,
     // Stashing should be disabled by default when the `diff` option is used
     stash = diff === undefined,
+    // Cannot revert to original state without stash
+    revert = stash,
     hidePartiallyStaged = stash,
     verbose = false,
   } = {},
@@ -112,7 +113,7 @@ const lintStaged = async (
     maxArgLength,
     quiet,
     relative,
-    shell,
+    revert,
     stash,
     hidePartiallyStaged,
     verbose,

package/lib/runAll.js

@@ -9,11 +9,12 @@ import { Listr } from 'listr2'
 import { chunkFiles } from './chunkFiles.js'
 import { execGit } from './execGit.js'
 import { generateTasks } from './generateTasks.js'
+import { getFunctionTask, isFunctionTask } from './getFunctionTask.js'
 import { getRenderer } from './getRenderer.js'
+import { getSpawnedTasks } from './getSpawnedTasks.js'
 import { getStagedFiles } from './getStagedFiles.js'
 import { GitWorkflow } from './gitWorkflow.js'
 import { groupFilesByConfig } from './groupFilesByConfig.js'
-import { makeCmdTasks } from './makeCmdTasks.js'
 import {
   DEPRECATED_GIT_ADD,
   FAILED_GET_STAGED_FILES,
@@ -58,7 +59,7 @@ const createError = (ctx) => Object.assign(new Error('lint-staged failed'), { ct
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
- * @param {boolean} [options.shell] - Skip parsing of tasks for better shell support
+ * @param {boolean} [options.revert] - revert to original state in case of errors
  * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
  * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
  * @param {Logger} logger
@@ -77,9 +78,10 @@ export const runAll = async (
     maxArgLength,
     quiet = false,
     relative = false,
-    shell = false,
     // Stashing should be disabled by default when the `diff` option is used
     stash = diff === undefined,
+    // Cannot revert to original state without stash
+    revert = stash,
     hidePartiallyStaged = stash,
     verbose = false,
   },
@@ -92,7 +94,7 @@ export const runAll = async (
   cwd = hasExplicitCwd ? path.resolve(cwd) : process.cwd()
   debugLog('Using working directory `%s`', cwd)
 
-  const ctx = getInitialState({ quiet })
+  const ctx = getInitialState({ quiet, revert })
 
   const { topLevelDir, gitConfigDir } = await resolveGitRepo(cwd)
   if (!topLevelDir) {
@@ -165,7 +167,7 @@ export const runAll = async (
    * This is used to set max event listener count to the total number
    * of generated tasks. The event listener is used to keep track of
    * the interrupt signal and kill all tasks when it happens. See the
-   * `interruptExecutionOnError` in `resolveTaskFn`.
+   * `interruptExecutionOnError` in `getSpawnedTask`.
    */
   let listrTaskCount = 0
 
@@ -192,14 +194,16 @@ export const runAll = async (
     for (const [index, files] of stagedFileChunks.entries()) {
       const chunkListrTasks = await Promise.all(
         generateTasks({ config, cwd: groupCwd, files, relative }).map((task) =>
-          makeCmdTasks({
-            commands: task.commands,
-            cwd: groupCwd,
-            files: task.fileList,
-            topLevelDir,
-            shell,
-            verbose,
-          }).then((subTasks) => {
+          (isFunctionTask(task.commands)
+            ? getFunctionTask(task.commands, files)
+            : getSpawnedTasks({
+                commands: task.commands,
+                cwd: groupCwd,
+                files: task.fileList,
+                topLevelDir,
+                verbose,
+              })
+          ).then((subTasks) => {
             // Add files from task to match set
             task.fileList.forEach((file) => {
               // Make sure relative files are normalized to the

package/lib/state.js

@@ -8,9 +8,10 @@ import {
   TaskError,
 } from './symbols.js'
 
-export const getInitialState = ({ quiet = false } = {}) => ({
+export const getInitialState = ({ quiet = false, revert = true } = {}) => ({
   hasPartiallyStagedFiles: null,
   shouldBackup: null,
+  shouldRevert: revert,
   backupHash: null,
   shouldHidePartiallyStaged: true,
   errors: new Set([]),
@@ -23,8 +24,8 @@ export const shouldHidePartiallyStagedFiles = (ctx) =>
   ctx.hasPartiallyStagedFiles && ctx.shouldHidePartiallyStaged
 
 export const applyModificationsSkipped = (ctx) => {
-  // Always apply back unstaged modifications when skipping backup
-  if (!ctx.shouldBackup) return false
+  // Always apply back unstaged modifications when skipping revert or backup
+  if (!ctx.shouldRevert || !ctx.shouldBackup) return false
   // Should be skipped in case of git errors
   if (ctx.errors.has(GitError)) {
     return GIT_ERROR
@@ -48,7 +49,9 @@ export const restoreUnstagedChangesSkipped = (ctx) => {
 }
 
 export const restoreOriginalStateEnabled = (ctx) =>
-  ctx.shouldBackup && (ctx.errors.has(TaskError) || ctx.errors.has(RestoreUnstagedChangesError))
+  !!ctx.shouldRevert &&
+  !!ctx.shouldBackup &&
+  (ctx.errors.has(TaskError) || ctx.errors.has(RestoreUnstagedChangesError))
 
 export const restoreOriginalStateSkipped = (ctx) => {
   // Should be skipped in case of unknown git errors

package/lib/validateConfig.js

@@ -10,19 +10,6 @@ import { validateBraces } from './validateBraces.js'
 
 const debugLog = debug('lint-staged:validateConfig')
 
-const isObject = (test) => test && typeof test === 'object' && !Array.isArray(test)
-
-const TEST_DEPRECATED_KEYS = new Map([
-  ['concurrent', (key) => typeof key === 'boolean'],
-  ['chunkSize', (key) => typeof key === 'number'],
-  ['globOptions', isObject],
-  ['linters', isObject],
-  ['ignore', (key) => Array.isArray(key)],
-  ['subTaskConcurrency', (key) => typeof key === 'number'],
-  ['renderer', (key) => typeof key === 'string'],
-  ['relative', (key) => typeof key === 'boolean'],
-])
-
 export const validateConfigLogic = (config, configPath, logger) => {
   debugLog('Validating config from `%s`...', configPath)
 
@@ -35,7 +22,7 @@ export const validateConfigLogic = (config, configPath, logger) => {
    * They are not further validated here to make sure the function gets
    * evaluated only once.
    *
-   * @see makeCmdTasks
+   * @see getSpawnedTasks
    */
   if (typeof config === 'function') {
     return { '*': config }
@@ -53,29 +40,30 @@ export const validateConfigLogic = (config, configPath, logger) => {
    * it can be used for validating the values at the same time.
    */
   const validatedConfig = Object.entries(config).reduce((collection, [pattern, task]) => {
-    /** Versions < 9 had more complex configuration options that are no longer supported. */
-    if (TEST_DEPRECATED_KEYS.has(pattern)) {
-      const testFn = TEST_DEPRECATED_KEYS.get(pattern)
-      if (testFn(task)) {
+    if (Array.isArray(task)) {
+      /** Array with invalid values */
+      if (task.some((item) => typeof item !== 'string' && typeof item !== 'function')) {
         errors.push(
-          configurationError(pattern, 'Advanced configuration has been deprecated.', task)
+          configurationError(pattern, 'Should be an array of strings or functions.', task)
         )
       }
-
-      /** Return early for deprecated keys to skip validating their (deprecated) values */
-      return collection
-    }
-
-    if (
-      (!Array.isArray(task) ||
-        task.some((item) => typeof item !== 'string' && typeof item !== 'function')) &&
-      typeof task !== 'string' &&
-      typeof task !== 'function'
-    ) {
+    } else if (typeof task === 'object') {
+      /** Invalid function task */
+      if (typeof task.title !== 'string' || typeof task.task !== 'function') {
+        errors.push(
+          configurationError(
+            pattern,
+            'Function task should contain `title` and `task` fields, where `title` should be a string and `task` should be a function.',
+            task
+          )
+        )
+      }
+    } else if (typeof task !== 'string' && typeof task !== 'function') {
+      /** Singular invalid value */
       errors.push(
         configurationError(
           pattern,
-          'Should be a string, a function, or an array of strings and functions.',
+          'Should be a string, a function, an object or an array of strings and functions.',
           task
         )
       )

package/lib/validateOptions.js

@@ -13,8 +13,6 @@ const debugLog = debug('lint-staged:validateOptions')
  * Validate lint-staged options, either from the Node.js API or the command line flags.
  * @param {*} options
  * @param {boolean|string} [options.cwd] - Current working directory
- * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
- *
  * @throws {InvalidOptionsError}
  */
 export const validateOptions = async (options = {}, logger) => {
@@ -32,16 +30,5 @@ export const validateOptions = async (options = {}, logger) => {
     }
   }
 
-  /** Ensure the passed shell option is executable */
-  if (typeof options.shell === 'string') {
-    try {
-      await fs.access(options.shell, constants.X_OK)
-    } catch (error) {
-      debugLog('Failed to validate options: %o', options)
-      logger.error(invalidOption('shell', options.shell, error.message))
-      throw InvalidOptionsError
-    }
-  }
-
   debugLog('Validated options: %o', options)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "15.5.2",
+  "version": "16.1.0",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,7 @@
     "url": "https://opencollective.com/lint-staged"
   },
   "engines": {
-    "node": ">=18.12.0"
+    "node": ">=20.17"
   },
   "type": "module",
   "bin": {
@@ -33,8 +33,9 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "bin",
-    "lib"
+    "bin/",
+    "lib/",
+    "MIGRATION.md"
   ],
   "scripts": {
     "lint": "eslint .",
@@ -47,37 +48,37 @@
   },
   "dependencies": {
     "chalk": "^5.4.1",
-    "commander": "^13.1.0",
-    "debug": "^4.4.0",
-    "execa": "^8.0.1",
+    "commander": "^14.0.0",
+    "debug": "^4.4.1",
     "lilconfig": "^3.1.3",
-    "listr2": "^8.2.5",
+    "listr2": "^8.3.3",
     "micromatch": "^4.0.8",
+    "nano-spawn": "^1.0.2",
     "pidtree": "^0.6.0",
     "string-argv": "^0.3.2",
-    "yaml": "^2.7.0"
+    "yaml": "^2.8.0"
   },
   "devDependencies": {
     "@changesets/changelog-github": "0.5.1",
-    "@changesets/cli": "2.28.1",
-    "@commitlint/cli": "19.8.0",
-    "@commitlint/config-conventional": "19.8.0",
-    "@eslint/js": "9.22.0",
+    "@changesets/cli": "2.29.4",
+    "@commitlint/cli": "19.8.1",
+    "@commitlint/config-conventional": "19.8.1",
+    "@eslint/js": "9.27.0",
     "consolemock": "1.1.0",
     "cross-env": "7.0.3",
-    "eslint": "9.22.0",
-    "eslint-config-prettier": "10.1.1",
+    "eslint": "9.27.0",
+    "eslint-config-prettier": "10.1.5",
     "eslint-plugin-jest": "28.11.0",
-    "eslint-plugin-n": "17.16.2",
-    "eslint-plugin-prettier": "5.2.3",
+    "eslint-plugin-n": "17.18.0",
+    "eslint-plugin-prettier": "5.4.0",
     "eslint-plugin-simple-import-sort": "12.1.1",
     "husky": "9.1.7",
     "jest": "29.7.0",
     "jest-snapshot-serializer-ansi": "2.2.1",
     "mock-stdin": "1.0.0",
     "prettier": "3.5.3",
-    "semver": "7.7.1",
-    "typescript": "5.8.2"
+    "semver": "7.7.2",
+    "typescript": "5.8.3"
   },
   "keywords": [
     "lint",