lint-staged 12.3.7 → 13.0.2

package/README.md

@@ -2,6 +2,10 @@
 
 Run linters against staged git files and don't let :poop: slip into your code base!
 
+```bash
+npm install --save-dev lint-staged # requires further setup
+```
+
 ```
 $ git commit
 
@@ -44,13 +48,17 @@ This project contains a script that will run arbitrary shell tasks with a list o
 
 ## Installation and setup
 
-The fastest way to start using lint-staged is to run the following command in your terminal:
-
-```bash
-npx mrm@2 lint-staged
-```
+To install _lint-staged_ in the recommended way, you need to:
 
-This command will install and configure [husky](https://github.com/typicode/husky) and lint-staged depending on the code quality tools from your project's `package.json` dependencies, so please make sure you install (`npm install --save-dev`) and configure all code quality tools like [Prettier](https://prettier.io) and [ESLint](https://eslint.org) prior to that.
+1. Install _lint-staged_ itself:
+   - `npm install --save-dev lint-staged`
+1. Set up the `pre-commit` git hook to run _lint-staged_
+   - [Husky](https://github.com/typicode/husky) is a popular choice for configuring git hooks
+   - Read more about git hooks [here](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks)
+1. Install some linters, like [ESLint](https://eslint.org) or [Prettier](https://prettier.io)
+1. Configure _lint-staged_ to run linters and other tasks:
+   - for example: `{ "*.js": "eslint" }` to run ESLint for all staged JS files
+   - See [Configuration](#Configuration) for more info
 
 Don't forget to commit changes to `package.json` and `.husky` to share this setup with your team!
 
@@ -64,6 +72,10 @@ See [Releases](https://github.com/okonet/lint-staged/releases).
 
 ### Migration
 
+#### 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.
+
 #### 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).
@@ -92,6 +104,10 @@ 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
+  --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
   -q, --quiet                        disable lint-staged’s own console output (default: false)
   -r, --relative                     pass relative filepaths to tasks (default: false)
@@ -102,7 +118,7 @@ Options:
 ```
 
 - **`--allow-empty`**: By default, when linter tasks undo all staged changes, lint-staged will exit with an error and abort the commit. Use this flag to allow creating empty git commits.
-- **`--concurrent [number|boolean]`**: Controls the concurrency of tasks being run by lint-staged. **NOTE**: This does NOT affect the concurrency of subtasks (they will always be run sequentially). Possible values are:
+- **`--concurrent [number|boolean]`**: Controls the [concurrency of tasks](#task-concurrency) being run by lint-staged. **NOTE**: This does NOT affect the concurrency of subtasks (they will always be run sequentially). Possible values are:
   - `false`: Run all tasks serially
   - `true` (default) : _Infinite_ concurrency. Runs as many tasks in parallel as possible.
   - `{number}`: Run the specified number of tasks in parallel, where `1` is equivalent to `false`.
@@ -111,6 +127,9 @@ Options:
 - **`--debug`**: Run in debug mode. When set, it does the following:
   - uses [debug](https://github.com/visionmedia/debug) internally to log additional information about staged files, commands being executed, location of binaries, etc. Debug logs, which are automatically enabled by passing the flag, can also be enabled by setting the environment variable `$DEBUG` to `lint-staged*`.
   - uses [`verbose` renderer](https://github.com/SamVerschueren/listr-verbose-renderer) for `listr`; this causes serial, uncoloured output to the terminal, instead of the default (beautified, dynamic) output.
+- **`--diff`**: By default linters 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).
+- **`--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.
 - **`--quiet`**: Supress all CLI output, except from tasks.
 - **`--relative`**: Pass filepaths relative to `process.cwd()` (where `lint-staged` runs) to tasks. Default is `false`.
@@ -119,7 +138,7 @@ Options:
 
 ## Configuration
 
-Starting with v3.1 you can now use different ways of configuring lint-staged:
+_Lint-staged_ can be configured in many ways:
 
 - `lint-staged` object in your `package.json`
 - `.lintstagedrc` file in JSON or YML format, or you can be explicit with the file extension:
@@ -162,6 +181,37 @@ So, considering you did `git add file1.ext file2.ext`, lint-staged will run the
 
 `your-cmd file1.ext file2.ext`
 
+### Task concurrency
+
+By default _lint-staged_ will run configured tasks concurrently. This means that for every glob, all the commands will be started at the same time. With the following config, both `eslint` and `prettier` will run at the same time:
+
+```json
+{
+  "*.ts": "eslint",
+  "*.md": "prettier --list-different"
+}
+```
+
+This is typically not a problem since the globs do not overlap, and the commands do not make changes to the files, but only report possible errors (aborting the git commit). If you want to run multiple commands for the same set of files, you can use the array syntax to make sure commands are run in order. In the following example, `prettier` will run for both globs, and in addition `eslint` will run for `*.ts` files _after_ it. Both sets of commands (for each glob) are still started at the same time (but do not overlap).
+
+```json
+{
+  "*.ts": ["prettier --list-different", "eslint"],
+  "*.md": "prettier --list-different"
+}
+```
+
+Pay extra attention when the configured globs overlap, and tasks make edits to files. For example, in this configuration `prettier` and `eslint` might try to make changes to the same `*.ts` file at the same time, causing a _race condition_:
+
+```json
+{
+  "*": "prettier --write",
+  "*.ts": "eslint --fix"
+}
+```
+
+If necessary, you can limit the concurrency using `--concurrent <number>` or disable it entirely with `--concurrent false`.
+
 ## Filtering files
 
 Linter commands work on a subset of all staged files, defined by a _glob pattern_. lint-staged uses [micromatch](https://github.com/micromatch/micromatch) for matching files with the following rules:
@@ -594,9 +644,9 @@ const success = await lintStaged({
   maxArgLength: null,
   quiet: false,
   relative: false,
-  shell: false
+  shell: false,
   stash: true,
-  verbose: false
+  verbose: false,
 })
 ```
 
@@ -713,6 +763,30 @@ Example repo: [sudo-suhas/lint-staged-django-react-demo](https://github.com/sudo
 
 </details>
 
+### Can I run `lint-staged` in CI, or when there are no staged files?
+
+<details>
+  <summary>Click to expand</summary>
+
+Lint-staged will by default run against files staged in git, and should be run during the git pre-commit hook, for example. It's also possible to override this default behaviour and run against files in a specific diff, for example
+all changed files between two different branches. If you want to run _lint-staged_ in the CI, maybe you can set it up to compare the branch in a _Pull Request_/_Merge Request_ to the target branch.
+
+Try out the `git diff` command until you are satisfied with the result, for example:
+
+```
+git diff --diff-filter=ACMR --name-only master...my-branch
+```
+
+This will print a list of _added_, _changed_, _modified_, and _renamed_ files between `master` and `my-branch`.
+
+You can then run lint-staged against the same files with:
+
+```
+npx lint-staged --diff="master...my-branch"
+```
+
+</details>
+
 ### Can I use `lint-staged` with `ng lint`
 
 <details>

package/bin/lint-staged.js

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 
-import fs from 'fs'
-import path from 'path'
-import { fileURLToPath } from 'url'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 
-import cmdline from 'commander'
+import { isColorSupported } from 'colorette'
+import { Option, program } from 'commander'
 import debug from 'debug'
-import supportsColor from 'supports-color'
 
 import lintStaged from '../lib/index.js'
 import { CONFIG_STDIN_ERROR } from '../lib/messages.js'
 
 // Force colors for packages that depend on https://www.npmjs.com/package/supports-color
-if (supportsColor.stdout) {
-  process.env.FORCE_COLOR = supportsColor.stdout.level.toString()
+if (isColorSupported) {
+  process.env.FORCE_COLOR = '1'
 }
 
 // Do not terminate main Listr process on SIGINT
@@ -23,67 +23,87 @@ const packageJsonPath = path.join(fileURLToPath(import.meta.url), '../../package
 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath))
 const version = packageJson.version
 
-cmdline
-  .version(version)
-  .option('--allow-empty', 'allow empty commits when tasks revert all staged changes', false)
-  .option(
-    '-p, --concurrent <number|boolean>',
-    'the number of tasks to run concurrently, or false for serial',
-    true
-  )
-  .option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
-  .option('--cwd [path]', 'run all tasks in specific directory, instead of the current')
-  .option('-d, --debug', 'print additional debug information', false)
-  .option('--no-stash', 'disable the backup stash, and do not revert in case of errors', false)
-  .option('-q, --quiet', 'disable lint-staged’s own console output', false)
-  .option('-r, --relative', 'pass relative filepaths to tasks', false)
-  .option('-x, --shell [path]', 'skip parsing of tasks for better shell support', false)
-  .option(
-    '-v, --verbose',
-    'show task output even when tasks succeed; by default only failed output is shown',
-    false
-  )
-  .parse(process.argv)
+const debugLog = debug('lint-staged:bin')
+debugLog('Running `lint-staged@%s`', version)
 
-const cmdlineOptions = cmdline.opts()
+const cli = program.version(version)
 
-if (cmdlineOptions.debug) {
-  debug.enable('lint-staged*')
-}
+cli.option('--allow-empty', 'allow empty commits when tasks revert all staged changes', false)
 
-const debugLog = debug('lint-staged:bin')
-debugLog('Running `lint-staged@%s`', version)
+cli.option(
+  '-p, --concurrent <number|boolean>',
+  'the number of tasks to run concurrently, or false for serial',
+  true
+)
+
+cli.option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
+
+cli.option('--cwd [path]', 'run all tasks in specific directory, instead of the current')
+
+cli.option('-d, --debug', 'print additional debug information', false)
+
+cli.option(
+  '--diff [string]',
+  'override the default "--staged" flag of "git diff" to get list of files. Implies "--no-stash".'
+)
+
+cli.option(
+  '--diff-filter [string]',
+  'override the default "--diff-filter=ACMR" flag of "git diff" to get list of files'
+)
+
+cli.option('--max-arg-length [number]', 'maximum length of the command-line argument string', 0)
 
 /**
- * Get the maximum length of a command-line argument string based on current platform
- *
- * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
- * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
- * https://unix.stackexchange.com/a/120652
+ * 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
+ * configuring only the latter won't actually set the default value.
  */
-const getMaxArgLength = () => {
-  switch (process.platform) {
-    case 'darwin':
-      return 262144
-    case 'win32':
-      return 8191
-    default:
-      return 131072
-  }
+cli
+  .addOption(
+    new Option('--stash', 'enable the backup stash, and revert in case of errors')
+      .default(true)
+      .hideHelp()
+  )
+  .addOption(
+    new Option(
+      '--no-stash',
+      'disable the backup stash, and do not revert in case of errors'
+    ).default(false)
+  )
+
+cli.option('-q, --quiet', 'disable lint-staged’s own console output', false)
+
+cli.option('-r, --relative', 'pass relative filepaths to tasks', false)
+
+cli.option('-x, --shell [path]', 'skip parsing of tasks for better shell support', false)
+
+cli.option(
+  '-v, --verbose',
+  'show task output even when tasks succeed; by default only failed output is shown',
+  false
+)
+
+const cliOptions = cli.parse(process.argv).opts()
+
+if (cliOptions.debug) {
+  debug.enable('lint-staged*')
 }
 
 const options = {
-  allowEmpty: !!cmdlineOptions.allowEmpty,
-  concurrent: JSON.parse(cmdlineOptions.concurrent),
-  configPath: cmdlineOptions.config,
-  cwd: cmdlineOptions.cwd,
-  debug: !!cmdlineOptions.debug,
-  maxArgLength: getMaxArgLength() / 2,
-  quiet: !!cmdlineOptions.quiet,
-  relative: !!cmdlineOptions.relative,
-  shell: cmdlineOptions.shell /* Either a boolean or a string pointing to the shell */,
-  stash: !!cmdlineOptions.stash, // commander inverts `no-<x>` flags to `!x`
-  verbose: !!cmdlineOptions.verbose,
+  allowEmpty: !!cliOptions.allowEmpty,
+  concurrent: JSON.parse(cliOptions.concurrent),
+  configPath: cliOptions.config,
+  cwd: cliOptions.cwd,
+  debug: !!cliOptions.debug,
+  diff: cliOptions.diff,
+  diffFilter: cliOptions.diffFilter,
+  maxArgLength: cliOptions.maxArgLength || undefined,
+  quiet: !!cliOptions.quiet,
+  relative: !!cliOptions.relative,
+  shell: cliOptions.shell /* Either a boolean or a string pointing to the shell */,
+  stash: !!cliOptions.stash, // commander inverts `no-<x>` flags to `!x`
+  verbose: !!cliOptions.verbose,
 }
 
 debugLog('Options parsed from command-line:', options)

package/lib/chunkFiles.js

@@ -1,4 +1,4 @@
-import path from 'path'
+import path from 'node:path'
 
 import debug from 'debug'
 import normalize from 'normalize-path'

package/lib/dynamicImport.js

@@ -1,3 +1,3 @@
-import { pathToFileURL } from 'url'
+import { pathToFileURL } from 'node:url'
 
 export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)

package/lib/execGit.js

@@ -1,5 +1,5 @@
 import debug from 'debug'
-import execa from 'execa'
+import { execa } from 'execa'
 
 const debugLog = debug('lint-staged:execGit')
 

package/lib/file.js

@@ -1,4 +1,4 @@
-import { promises as fs } from 'fs'
+import fs from 'node:fs/promises'
 
 import debug from 'debug'
 

package/lib/generateTasks.js

@@ -1,4 +1,4 @@
-import path from 'path'
+import path from 'node:path'
 
 import debug from 'debug'
 import micromatch from 'micromatch'
@@ -21,9 +21,7 @@ export const generateTasks = ({ config, cwd = process.cwd(), files, relative = f
 
   const relativeFiles = files.map((file) => normalize(path.relative(cwd, file)))
 
-  return Object.entries(config).map(([rawPattern, commands]) => {
-    let pattern = rawPattern
-
+  return Object.entries(config).map(([pattern, commands]) => {
     const isParentDirPattern = pattern.startsWith('../')
 
     // Only worry about children of the CWD unless the pattern explicitly
@@ -40,6 +38,7 @@ export const generateTasks = ({ config, cwd = process.cwd(), files, relative = f
       // match against filenames in every directory. This makes `*.js`
       // match both `test.js` and `subdirectory/test.js`.
       matchBase: !pattern.includes('/'),
+      posixSlashes: true,
       strictBrackets: true,
     })
 

package/lib/getDiffCommand.js

@@ -0,0 +1,18 @@
+export function getDiffCommand(diff, diffFilter) {
+  /**
+   *  Docs for --diff-filter option:
+   * @see https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203
+   */
+  const diffFilterArg = diffFilter !== undefined ? diffFilter.trim() : 'ACMR'
+
+  /** Use `--diff branch1...branch2` or `--diff="branch1 branch2", or fall back to default staged files */
+  const diffArgs = diff !== undefined ? diff.trim().split(' ') : ['--staged']
+
+  /**
+   * Docs for -z option:
+   * @see https://git-scm.com/docs/git-diff#Documentation/git-diff.txt--z
+   */
+  const diffCommand = ['diff', '--name-only', '-z', `--diff-filter=${diffFilterArg}`, ...diffArgs]
+
+  return diffCommand
+}

package/lib/getStagedFiles.js

@@ -1,18 +1,14 @@
-import path from 'path'
+import path from 'node:path'
 
 import normalize from 'normalize-path'
 
 import { execGit } from './execGit.js'
+import { getDiffCommand } from './getDiffCommand.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 
-export const getStagedFiles = async ({ cwd = process.cwd() } = {}) => {
+export const getStagedFiles = async ({ cwd = process.cwd(), diff, diffFilter } = {}) => {
   try {
-    // Docs for --diff-filter option: https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203
-    // Docs for -z option: https://git-scm.com/docs/git-diff#Documentation/git-diff.txt--z
-    const lines = await execGit(['diff', '--staged', '--diff-filter=ACMR', '--name-only', '-z'], {
-      cwd,
-    })
-
+    const lines = await execGit(getDiffCommand(diff, diffFilter), { cwd })
     if (!lines) return []
 
     return parseGitZOutput(lines).map((file) => normalize(path.resolve(cwd, file)))

package/lib/gitWorkflow.js

@@ -1,9 +1,10 @@
-import path from 'path'
+import path from 'node:path'
 
 import debug from 'debug'
 
 import { execGit } from './execGit.js'
 import { readFile, unlink, writeFile } from './file.js'
+import { getDiffCommand } from './getDiffCommand.js'
 import {
   GitError,
   RestoreOriginalStateError,
@@ -65,12 +66,13 @@ const handleError = (error, ctx, symbol) => {
 }
 
 export class GitWorkflow {
-  constructor({ allowEmpty, gitConfigDir, gitDir, matchedFileChunks }) {
+  constructor({ allowEmpty, gitConfigDir, gitDir, matchedFileChunks, diff, diffFilter }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: gitDir })
     this.deletedFiles = []
     this.gitConfigDir = gitConfigDir
     this.gitDir = gitDir
-    this.unstagedDiff = null
+    this.diff = diff
+    this.diffFilter = diffFilter
     this.allowEmpty = allowEmpty
     this.matchedFileChunks = matchedFileChunks
 
@@ -262,7 +264,7 @@ export class GitWorkflow {
 
     debugLog('Done adding task modifications to index!')
 
-    const stagedFilesAfterAdd = await this.execGit(['diff', '--name-only', '--cached'])
+    const stagedFilesAfterAdd = await this.execGit(getDiffCommand(this.diff, this.diffFilter))
     if (!stagedFilesAfterAdd && !this.allowEmpty) {
       // Tasks reverted all staged changes and the commit would be empty
       // Throw error to stop commit unless `--allow-empty` was used

package/lib/groupFilesByConfig.js

@@ -0,0 +1,55 @@
+import path from 'node:path'
+
+import debug from 'debug'
+
+const debugLog = debug('lint-staged:groupFilesByConfig')
+
+export const groupFilesByConfig = async ({ configs, files, singleConfigMode }) => {
+  debugLog('Grouping %d files by %d configurations', files.length, Object.keys(configs).length)
+
+  const filesSet = new Set(files)
+  const filesByConfig = {}
+
+  /** Configs are sorted deepest first by `searchConfigs` */
+  for (const [filepath, config] of Object.entries(configs)) {
+    /** When passed an explicit config object via the Node.js API‚ or an explicit path, skip logic */
+    if (singleConfigMode) {
+      filesByConfig[filepath] = { config, files }
+      break
+    }
+
+    const dir = path.normalize(path.dirname(filepath))
+
+    /** Check if file is inside directory of the configuration file */
+    const isInsideDir = (file) => {
+      const relative = path.relative(dir, file)
+      return relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+    }
+
+    /** This config should match all files since it has a parent glob */
+    const includeAllFiles = Object.keys(config).some((glob) => glob.startsWith('..'))
+
+    const scopedFiles = new Set(includeAllFiles ? filesSet : undefined)
+
+    /**
+     * Without a parent glob, if file is inside the config file's directory,
+     * assign it to that configuration.
+     */
+    if (!includeAllFiles) {
+      filesSet.forEach((file) => {
+        if (isInsideDir(file)) {
+          scopedFiles.add(file)
+        }
+      })
+    }
+
+    /** Files should only match a single config */
+    scopedFiles.forEach((file) => {
+      filesSet.delete(file)
+    })
+
+    filesByConfig[filepath] = { config, files: Array.from(scopedFiles) }
+  }
+
+  return filesByConfig
+}

package/lib/index.js

@@ -1,13 +1,41 @@
 import debug from 'debug'
 
-import { PREVENTED_EMPTY_COMMIT, GIT_ERROR, RESTORE_STASH_EXAMPLE } from './messages.js'
+import {
+  PREVENTED_EMPTY_COMMIT,
+  GIT_ERROR,
+  RESTORE_STASH_EXAMPLE,
+  NO_CONFIGURATION,
+} from './messages.js'
 import { printTaskOutput } from './printTaskOutput.js'
 import { runAll } from './runAll.js'
-import { ApplyEmptyCommitError, GetBackupStashError, GitError } from './symbols.js'
+import {
+  ApplyEmptyCommitError,
+  ConfigNotFoundError,
+  GetBackupStashError,
+  GitError,
+} from './symbols.js'
 import { validateOptions } from './validateOptions.js'
 
 const debugLog = debug('lint-staged')
 
+/**
+ * Get the maximum length of a command-line argument string based on current platform
+ *
+ * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
+ * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
+ * https://unix.stackexchange.com/a/120652
+ */
+const getMaxArgLength = () => {
+  switch (process.platform) {
+    case 'darwin':
+      return 262144
+    case 'win32':
+      return 8191
+    default:
+      return 131072
+  }
+}
+
 /**
  * @typedef {(...any) => void} LogFunction
  * @typedef {{ error: LogFunction, log: LogFunction, warn: LogFunction }} Logger
@@ -21,6 +49,8 @@ const debugLog = debug('lint-staged')
  * @param {string} [options.configPath] - Path to configuration file
  * @param {Object} [options.cwd] - Current working directory
  * @param {boolean} [options.debug] - Enable debug mode
+ * @param {string} [options.diff] - Override the default "--staged" flag of "git diff" to get list of files
+ * @param {string} [options.diffFilter] - Override the default "--diff-filter=ACMR" flag of "git diff" to get list of files
  * @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
@@ -39,7 +69,9 @@ const lintStaged = async (
     configPath,
     cwd,
     debug = false,
-    maxArgLength,
+    diff,
+    diffFilter,
+    maxArgLength = getMaxArgLength() / 2,
     quiet = false,
     relative = false,
     shell = false,
@@ -54,31 +86,35 @@ const lintStaged = async (
   debugLog('Unset GIT_LITERAL_PATHSPECS (was `%s`)', process.env.GIT_LITERAL_PATHSPECS)
   delete process.env.GIT_LITERAL_PATHSPECS
 
+  const options = {
+    allowEmpty,
+    concurrent,
+    configObject,
+    configPath,
+    cwd,
+    debug,
+    diff,
+    diffFilter,
+    maxArgLength,
+    quiet,
+    relative,
+    shell,
+    stash,
+    verbose,
+  }
+
   try {
-    const ctx = await runAll(
-      {
-        allowEmpty,
-        concurrent,
-        configObject,
-        configPath,
-        cwd,
-        debug,
-        maxArgLength,
-        quiet,
-        relative,
-        shell,
-        stash,
-        verbose,
-      },
-      logger
-    )
+    const ctx = await runAll(options, logger)
     debugLog('Tasks were executed successfully!')
     printTaskOutput(ctx, logger)
     return true
   } catch (runAllError) {
-    if (runAllError && runAllError.ctx && runAllError.ctx.errors) {
+    if (runAllError?.ctx?.errors) {
       const { ctx } = runAllError
-      if (ctx.errors.has(ApplyEmptyCommitError)) {
+
+      if (ctx.errors.has(ConfigNotFoundError)) {
+        logger.error(NO_CONFIGURATION)
+      } else if (ctx.errors.has(ApplyEmptyCommitError)) {
         logger.warn(PREVENTED_EMPTY_COMMIT)
       } else if (ctx.errors.has(GitError) && !ctx.errors.has(GetBackupStashError)) {
         logger.error(GIT_ERROR)

package/lib/messages.js

@@ -22,12 +22,20 @@ export const incorrectBraces = (before, after) =>
 `
   )
 
+export const NO_CONFIGURATION = `${error} No valid configuration found.`
+
 export const NO_STAGED_FILES = `${info} No staged files found.`
 
 export const NO_TASKS = `${info} No staged files match any configured task.`
 
-export const skippingBackup = (hasInitialCommit) => {
-  const reason = hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet'
+export const skippingBackup = (hasInitialCommit, diff) => {
+  const reason =
+    diff !== undefined
+      ? '`--diff` was used'
+      : hasInitialCommit
+      ? '`--no-stash` was used'
+      : 'there’s no initial commit yet'
+
   return yellow(`${warning} Skipping backup because ${reason}.\n`)
 }